PrepBro
← Назад к вопросам

Что такое Java Collections?

1.0 Junior🔥 211 комментариев
#Коллекции#Основы Java

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI23 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Java Collections Framework: полное руководство

Java Collections Framework — это фундаментальная часть Java Standard Library. Это набор интерфейсов и классов для работы с группами объектов. Давайте разберемся подробно.

Иерархия Collections Framework

Все коллекции наследуют от базового интерфейса Iterable:

Iterable
  |
  +-- Collection
       |
       +-- List (упорядоченная, с индексами)
       |    +-- ArrayList
       |    +-- LinkedList
       |    +-- Vector (устаревший)
       |    +-- CopyOnWriteArrayList
       |
       +-- Set (уникальные элементы, без порядка)
       |    +-- HashSet
       |    +-- LinkedHashSet
       |    +-- TreeSet
       |    +-- EnumSet
       |
       +-- Queue (FIFO очередь)
            +-- LinkedList
            +-- PriorityQueue
            +-- Deque (двусторонняя очередь)
                 +-- ArrayDeque
                 +-- LinkedList

Map (не наследует Collection, отдельная иерархия)
  +-- HashMap
  +-- LinkedHashMap
  +-- TreeMap
  +-- Hashtable (устаревший)
  +-- ConcurrentHashMap

List: упорядоченные коллекции с индексами

Элементы имеют определенный порядок, доступ по индексу:

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

// Доступ по индексу
String first = names.get(0);  // "Alice"

// Порядок сохраняется
for (String name : names) {
    System.out.println(name);  // Alice, Bob, Charlie в этом порядке
}

// Вставка в середину
names.add(1, "David");  // Alice, David, Bob, Charlie

ArrayList vs LinkedList:

// ArrayList — быстрый доступ по индексу O(1)
List<String> arrayList = new ArrayList<>();  // Используйте по умолчанию
arrayList.get(500);  // Быстро O(1)
arrayList.add("item");  // Быстро O(1) амортизировано

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

Set: уникальные элементы

Нет дублей, нет гарантированного порядка (кроме LinkedHashSet и TreeSet):

Set<String> colors = new HashSet<>();
colors.add("red");
colors.add("blue");
colors.add("red");  // Дубль, не добавится

System.out.println(colors.size());  // 2, не 3

// Проверка наличия элемента
if (colors.contains("red")) {
    System.out.println("Has red");
}

HashSet vs LinkedHashSet vs TreeSet:

// HashSet — быстрый поиск O(1), случайный порядок
Set<Integer> hashSet = new HashSet<>();
hashSet.add(3);
hashSet.add(1);
hashSet.add(2);
// Порядок: может быть 1, 3, 2 или 2, 1, 3

// LinkedHashSet — сохраняет порядок вставки
Set<Integer> linkedSet = new LinkedHashSet<>();
linkedSet.add(3);
linkedSet.add(1);
linkedSet.add(2);
// Порядок: 3, 1, 2 (как вставляли)

// TreeSet — отсортирован, медленнее O(log n)
Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
// Порядок: 1, 2, 3 (отсортирован)

Map: ключ-значение пары

Отображение значений по ключам:

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.put("Bob", 30);
ages.put("Charlie", 28);

// Получение значения по ключу
Integer aliceAge = ages.get("Alice");  // 25

// Проверка наличия ключа
if (ages.containsKey("Bob")) {
    System.out.println("Bob's age: " + ages.get("Bob"));
}

// Итерация
for (String name : ages.keySet()) {
    System.out.println(name + ": " + ages.get(name));
}

// Или через entrySet (эффективнее)
for (Map.Entry<String, Integer> entry : ages.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

HashMap vs LinkedHashMap vs TreeMap:

// HashMap — быстро O(1), случайный порядок
Map<String, String> hashMap = new HashMap<>();

// LinkedHashMap — сохраняет порядок вставки
Map<String, String> linkedMap = new LinkedHashMap<>();
linkedMap.put("z", "last");
linkedMap.put("a", "first");
// Порядок: z, a (как вставляли)

// TreeMap — отсортирован по ключам
Map<String, String> treeMap = new TreeMap<>();
treeMap.put("z", "last");
treeMap.put("a", "first");
// Порядок: a, z (отсортировано)

Queue: FIFO очередь

Первый вошел — первый вышел:

Queue<String> queue = new LinkedList<>();
queue.offer("first");    // add в очередь
queue.offer("second");
queue.offer("third");

String next = queue.poll();  // Удалить первый (first)
String peek = queue.peek();  // Смотреть первый (second), не удалять

PriorityQueue — приоритетная очередь:

Queue<Integer> pq = new PriorityQueue<>();  // Min-heap по умолчанию
pq.offer(5);
pq.offer(1);
pq.offer(3);

int min = pq.poll();  // 1 (минимум в приоритете)
int min2 = pq.poll();  // 3
int min3 = pq.poll();  // 5

Deque: двусторонняя очередь

Можно добавлять и удалять с обеих сторон:

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("a");
deque.addLast("b");
deque.addFirst("c");  // c, a, b

String first = deque.removeFirst();  // c
String last = deque.removeLast();    // b
// Осталось: a

Важные методы Collections

// Поиск max/min
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
int max = Collections.max(numbers);      // 9
int min = Collections.min(numbers);      // 1

// Сортировка
Collections.sort(numbers);               // [1, 1, 3, 4, 5, 9]

// Сортировка в обратном порядке
Collections.sort(numbers, Collections.reverseOrder());

// Поиск бинарный
int index = Collections.binarySearch(numbers, 4);  // индекс 4

// Перемешивание
Collections.shuffle(numbers);

// Синхронизированные коллекции (потокобезопасные)
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

Stream API для коллекций (Java 8+)

Современный способ работы с коллекциями:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

// Фильтр и преобразование
List<Integer> evenDoubled = numbers.stream()
    .filter(n -> n % 2 == 0)      // 2, 4, 6
    .map(n -> n * 2)              // 4, 8, 12
    .collect(Collectors.toList());

// Параллельная обработка
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<Integer> lengths = names.parallelStream()
    .map(String::length)
    .collect(Collectors.toList());

Best Practices

// 1. Используйте интерфейсы, не конкретные классы
List<String> list = new ArrayList<>();  // Правильно
ArrayList<String> list = new ArrayList<>();  // Менее гибко

// 2. Выбирайте правильную коллекцию
// Нужны уникальные элементы? → Set
// Нужен порядок? → List или LinkedHashSet
// Нужно быстро найти по ключу? → Map

// 3. Инициализация с capacity предотвращает переаллокации
List<String> list = new ArrayList<>(100);  // Оптимизация

// 4. Используйте try-with-resources для AutoCloseable
// (большинство коллекций не AutoCloseable, но важно помнить)

Вывод

Java Collections Framework — набор интерфейсов и классов для работы с группами объектов:

  • List — упорядоченные коллекции (ArrayList, LinkedList)
  • Set — уникальные элементы (HashSet, TreeSet)
  • Map — ключ-значение пары (HashMap, TreeMap)
  • Queue — FIFO очереди (LinkedList, PriorityQueue)

Выбор правильной коллекции критичен для performance. Используйте ArrayList по умолчанию, добавляйте элементы в HashSet для O(1) поиска, и HashMap для быстрого доступа по ключу.

Что такое Java Collections? | PrepBro