⚖️ Вопросы СРАВНЕНИЯ по Java

Ответ: Iterable и Iterator — это два важных интерфейса в Java для итерирования коллекций, но они выполняют разные роли:

• Iterable: Это интерфейс, который представляет коллекцию, которая может быть итерирована. Класс реализует Iterable, чтобы разрешить итерирование своих элементов.
• Iterator: Это интерфейс, который предоставляет методы для итерирования через коллекцию. Iterator используется для перемещения по элементам.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

// Iterable (for-each loop использует Iterable)
for (String lang : list) {
    System.out.println(lang);
}

// Iterator (явное использование)
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}
                

Ответ: List и Set — это два основных интерфейса Collection Framework с разными характеристиками:

// List - упорядочен, разрешает дубликаты
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Apple");  // Дубликат разрешен
System.out.println(list);  // [Apple, Banana, Apple]
System.out.println(list.get(0));  // Apple - доступ по индексу

// Set - неупорядочен, НЕ разрешает дубликаты
Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Apple");  // Дубликат игнорируется
System.out.println(set);  // [Apple, Banana] или [Banana, Apple]
                

Ответ: List и Map — это два разных интерфейса в Collection Framework с разными способами хранения и доступа к данным:

// List - хранит элементы в порядке
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println(list);  // [Java, Python, C++]
System.out.println(list.get(1));  // Python - доступ по индексу

// Map - хранит пары ключ-значение
Map<String, Integer> map = new HashMap<>();
map.put("Java", 95);
map.put("Python", 87);
map.put("C++", 92);
System.out.println(map);  // {Java=95, Python=87, C++=92}
System.out.println(map.get("Java"));  // 95 - доступ по ключу
                

• List: Коллекция значений с порядком, доступ по индексу
• Map: Коллекция пар ключ-значение, доступ по ключу

Ответ: Queue и Stack — это две важные структуры данных с противоположными порядками обработки элементов:

Queue (FIFO): [1] [2] [3] [4] → Удалить 1 сначала

Stack (LIFO): [1] [2] [3] [4] → Удалить 4 сначала (вершина)

// Queue - FIFO
Queue<Integer> queue = new LinkedList<>();
queue.add(1);
queue.add(2);
queue.add(3);
System.out.println(queue.poll());  // 1 (первый добавленный удаляется первым)

// Stack - LIFO
Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.pop());   // 3 (последний добавленный удаляется первым)
                

Ответ: PriorityQueue и TreeSet — это две разные структуры данных с разными характеристиками и использованием:

// PriorityQueue - разрешает дубликаты, упорядочивает по приоритету
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(5);
pq.add(10);
pq.add(5);  // Дубликат разрешен
System.out.println(pq.peek());  // 5 (с наивысшим приоритетом)

// TreeSet - НЕ разрешает дубликаты, автоматически сортируется
TreeSet<Integer> ts = new TreeSet<>();
ts.add(5);
ts.add(10);
ts.add(5);   // Дубликат игнорируется
System.out.println(ts);  // [5, 10] - автоматически отсортировано
                

• PriorityQueue: Очередь с приоритетами, разрешает дубликаты, основана на Queue
• TreeSet: Отсортированное множество, НЕ разрешает дубликаты, основана на Set

Ответ: Singly Linked List и Doubly Linked List — это две разные реализации связных списков с разными характеристиками:

// Singly Linked List - только forward traversal
LinkedList<String> singlyList = new LinkedList<>();
singlyList.add("A");
singlyList.add("B");
singlyList.add("C");

// Только вперед
for (String element : singlyList) {
    System.out.println(element);  // A, B, C
}

// Doubly Linked List (в Java это просто LinkedList)
LinkedList<String> doublyList = new LinkedList<>();
doublyList.add("A");
doublyList.add("B");
doublyList.add("C");

// Можно обходить в обе стороны
Iterator<String> iterator = doublyList.descendingIterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());  // C, B, A (в обратном порядке)
}
                

• Singly: Один указатель (next), обход только вперед, меньше памяти
• Doubly: Два указателя (prev, next), обход в обе стороны, больше памяти

Ответ: Failfast и Failsafe — это два разных подхода к обработке одновременных модификаций при итерировании коллекций:

Failfast Пример (выбросит исключение):

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
    if (element.equals("B")) {
        list.remove("B");  // ConcurrentModificationException!
    }
}
                

Failsafe Пример (не выбросит исключение):

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
    if (element.equals("B")) {
        list.remove("B");  // Работает нормально!
    }
}
                

• ArrayList
• HashMap
• HashSet
• LinkedList

• CopyOnWriteArrayList
• ConcurrentHashMap
• CopyOnWriteArraySet

Ответ: HashMap и TreeMap — это две разные реализации Map интерфейса с разными характеристиками и производительностью:

// HashMap - без гарантированного порядка
Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Zebra", 3);
hashMap.put("Apple", 1);
hashMap.put("Mango", 2);

System.out.println(hashMap);  
// Может быть: {Mango=2, Zebra=3, Apple=1} или другой порядок

// TreeMap - отсортирован по ключам
Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Zebra", 3);
treeMap.put("Apple", 1);
treeMap.put("Mango", 2);

System.out.println(treeMap);  
// Всегда: {Apple=1, Mango=2, Zebra=3} - отсортирован!
                

• HashMap: Когда нужна быстрая производительность и порядок не важен
• TreeMap: Когда нужны отсортированные данные или нужна потокобезопасность

Ответ: Queue и Deque (Double Ended Queue) — это две разные структуры данных для управления коллекциями элементов:

// Queue - FIFO, добавление только в конце
Queue<Integer> queue = new LinkedList<>();
queue.add(1);
queue.add(2);
queue.add(3);
System.out.println(queue.poll());  // 1 (первый добавленный)

// Deque - добавление с обоих концов
Deque<Integer> deque = new LinkedList<>();
deque.addFirst(1);   // Добавить в начало
deque.addLast(2);    // Добавить в конец
deque.addLast(3);
System.out.println(deque.removeFirst());  // 1 (с начала)
System.out.println(deque.removeLast());   // 3 (с конца)
                

Ответ: HashSet и TreeSet — это две разные реализации Set интерфейса с разными характеристиками:

HashSet:

• Неупорядоченная коллекция элементов
• Разрешает null элементы
• Использует хеш-таблицу для хранения элементов
• Быстрая производительность для операций add, remove, contains
• Порядок итерирования не гарантирован

TreeSet:

• Упорядоченная коллекция элементов на основе естественного порядка (сортировка)
• НЕ разрешает null элементы (выбросит NullPointerException)
• Использует Red-Black дерево для хранения элементов
• Более медленная производительность по сравнению с HashSet
• Порядок итерирования всегда отсортирован

// HashSet - неупорядоченный, разрешает null
Set<String> hashSet = new HashSet<>();
hashSet.add("Zebra");
hashSet.add("Apple");
hashSet.add("Mango");
hashSet.add(null);  // Разрешено

System.out.println(hashSet);  
// Может быть: [Mango, Zebra, Apple, null] или другой порядок

// TreeSet - упорядоченный, НЕ разрешает null
Set<String> treeSet = new TreeSet<>();
treeSet.add("Zebra");
treeSet.add("Apple");
treeSet.add("Mango");
// treeSet.add(null);  // Выбросит NullPointerException!

System.out.println(treeSet);  
// Всегда: [Apple, Mango, Zebra] - отсортировано!
                

• HashSet: Когда нужна максимальная производительность и порядок не важен
• TreeSet: Когда нужны отсортированные данные и порядок важен

Ответ: Сложность операций зависит от внутренней структуры: ArrayList хранит элементы в массиве, LinkedList — в двусвязном списке, а HashSet и HashMap — в хеш-таблице (HashSet внутри использует HashMap).

• ArrayList.add — O(1) только амортизированно: когда массив заполнен, создаётся новый (примерно в 1,5 раза больше) и все элементы копируются за O(n)
• ArrayList.add(i, x) и remove(i) сдвигают все элементы справа от позиции через System.arraycopy
• LinkedList.add(i, x) — O(1) только если позиция уже известна (например, у итератора). Чтобы дойти до индекса, нужно пройти по узлам: O(n)
• HashSet и HashMap — O(1) в среднем, если хеш-функция равномерная. При большом числе коллизий bucket превращается в красно-чёрное дерево (Java 8+), и худший случай — O(log n); в старых версиях и без дерева это O(n)
• При превышении loadFactor (по умолчанию 0,75) таблица удваивается с перехешированием — это O(n), но редкая операция

List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();
Set<Integer> hashSet = new HashSet<>();
Map<Integer, String> hashMap = new HashMap<>();

arrayList.add(10);          // O(1) амортизированно
arrayList.add(0, 5);        // O(n): все элементы сдвигаются вправо
arrayList.get(1);           // O(1): доступ по индексу

linkedList.add(10);         // O(1): добавление в конец
linkedList.get(1);          // O(n): обход узлов от начала или конца

hashSet.add(10);            // O(1) в среднем
hashSet.contains(10);       // O(1) в среднем

hashMap.put(1, "one");      // O(1) в среднем
hashMap.get(1);             // O(1) в среднем