В чем разница между Interface List и Interface Set?

Разница между List и Set в Java Collections

List и Set — это две основные коллекции в Java, которые имеют важные различия в том, как они хранят и управляют элементами. Выбор между ними критичен для правильного проектирования приложений.

Основные различия

1. Порядок элементов

List сохраняет порядок вставки элементов:

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

for (String item : list) {
    System.out.println(item);
}
// Вывод (гарантированный порядок):
// Apple
// Banana
// Cherry

Set НЕ гарантирует порядок (кроме специальных реализаций):

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");

for (String item : set) {
    System.out.println(item);
}
// Вывод может быть в любом порядке
// (в зависимости от хеша элементов)

2. Дубликаты элементов

List позволяет хранить дубликаты:

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Apple");
list.add("Apple");

System.out.println(list.size());  // 3

Set не допускает дубликаты:

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Apple");
set.add("Apple");

System.out.println(set.size());   // 1 (только уникальные)

3. Доступ к элементам

List позволяет доступ по индексу:

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");

String first = list.get(0);       // Apple
String second = list.get(1);      // Banana

list.set(1, "Blueberry");         // Замена по индексу

Set НЕ имеет доступа по индексу (нет get(int index)):

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");

// set.get(0); // Ошибка компиляции - метода нет

// Только итерация
for (String item : set) {
    // обработка
}

Иерархия и реализации

Реализации List

// ArrayList — самая часто используемая, быстрый доступ
List<String> arrayList = new ArrayList<>();
arrayList.add("item");
System.out.println(arrayList.get(0));  // O(1)

// LinkedList — вставка/удаление в начало/конец, медленный доступ
List<String> linkedList = new LinkedList<>();
linkedList.add(0, "item");  // O(1) вставка в начало
linkedList.get(0);          // O(n) доступ

// Vector — синхронизирован, устаревший
List<String> vector = new Vector<>();

// Collections.synchronizedList() — потокобезопасный ArrayList
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

Реализации Set

// HashSet — быстрый поиск O(1), беспорядочный порядок
Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
booleanhas = hashSet.contains("Apple");  // O(1)

// TreeSet — отсортирован, O(log n) операции
Set<String> treeSet = new TreeSet<>();  // отсортировано
treeSet.add("Banana");
treeSet.add("Apple");  // Автоматически отсортируется
for (String item : treeSet) {
    System.out.println(item); // Apple, Banana (отсортировано)
}

// LinkedHashSet — сохраняет порядок вставки
Set<String> linkedSet = new LinkedHashSet<>();
linkedSet.add("Apple");
linkedSet.add("Banana");
for (String item : linkedSet) {
    System.out.println(item); // Apple, Banana (порядок сохранен)
}

Сравнение операций

Когда использовать List

// Когда нужна последовательность элементов
List<String> tasks = new ArrayList<>();
tasks.add("Task 1");
tasks.add("Task 2");
tasks.add("Task 3");

// Обработка по порядку
for (int i = 0; i < tasks.size(); i++) {
    System.out.println((i + 1) + ". " + tasks.get(i));
}

// Когда нужны дубликаты
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(1);
numbers.add(1);  // Все три 1 будут сохранены

// Когда нужен доступ по индексу
String middle = tasks.get(tasks.size() / 2);

Когда использовать Set

// Когда нужны только уникальные элементы
Set<String> uniqueEmails = new HashSet<>();
uniqueEmails.add("john@example.com");
uniqueEmails.add("john@example.com");  // Не будет добавлено

System.out.println(uniqueEmails.size());  // 1

// Быстрая проверка наличия элемента
Set<String> allowedUsers = new HashSet<>();
allowedUsers.add("admin");
allowedUsers.add("user");

if (allowedUsers.contains(currentUser)) {
    // Разрешить доступ
}

// Удаление дубликатов из List
List<Integer> listWithDuplicates = Arrays.asList(1, 2, 2, 3, 3, 3);
Set<Integer> unique = new HashSet<>(listWithDuplicates);
List<Integer> uniqueList = new ArrayList<>(unique);

// Операции множеств (объединение, пересечение)
Set<String> set1 = new HashSet<>(Arrays.asList("A", "B", "C"));
Set<String> set2 = new HashSet<>(Arrays.asList("B", "C", "D"));

set1.retainAll(set2);  // Пересечение: B, C
set1.addAll(set2);     // Объединение

Практический пример: выбор между List и Set

// Вариант 1: Нужны ВСЕ заказы в порядке создания
List<Order> orders = new ArrayList<>();  // List!
ordera.add(order1);
orders.add(order2);
orders.add(order1);  // Дубликат допускается

// Вариант 2: Нужны УНИКАЛЬНЫЕ ID заказов для быстрой проверки
Set<Long> processedOrderIds = new HashSet<>();  // Set!
if (!processedOrderIds.contains(orderId)) {
    processedOrderIds.add(orderId);
    // Обработать
}

// Вариант 3: Нужны уникальные элементы в отсортированном порядке
Set<String> sortedCountries = new TreeSet<>();
sortedCountries.add("USA");
sortedCountries.add("Canada");
sortedCountries.add("Brazil");
for (String country : sortedCountries) {
    System.out.println(country);  // Вывод в алфавитном порядке
}

Итоговая таблица

Выбор между List и Set зависит от того, что вы хотите сделать с данными. List когда порядок и дубликаты важны, Set когда нужны уникальные элементы и быстрая проверка.