• Интерфейсы
• Реализации
• Алгоритмы

• <E> ─ тип элемента

• size() ─ количество элементов
• isEmpty() ─ проверка на пустоту

• contains(object) ─ одного элемента
• containsAll(c) ─ всех элементов c

• boolean add(e) ─ одного
• boolean addAll(collection<+E>) ─ коллекции

• boolean remove(object) ─ одного
• boolean removeAll(collection<?>) ─ коллекции
• boolean retainAll(collection<?>) ─ удаление элементов не из коллекции
• clear() ─ всех элементов

• UnsupportedOperationException

• Метод Iterator<E> collection<E>.iterator()

• hasNext() ─ наличие элемента
• next() ─ получение элемента
• remove() ─ удаление элемента

• NoSuchElementException ─ нет элементов
• ConcurrentModificationException ─ коллекция изменена

for (Iterator<E> i = c.iterator(); i.hasNext(); ) {
    final E element = i.next();
    ...
}

for (Iterator<E> i = c.iterator(); i.hasNext(); ) {
    if (!p(i.next()) {
        i.remove();
    }
}

• Интерфейс Iterable<T>
• Метод iterator()

• for (T element : collection) {
      ...
  }
  

• for (Iterator<T> i = collection.iterator(); i.hasNext(); ) {
      T element = i.next();
      ...
  }
  

public void dump(Collection<String> c) {
    for (Iterator<String> i = c.iterator(); i.hasNext(); ) {
        final String word = i.next();
        System.out.print(word + ", ");
    }
    System.out.println();
}

• Object[] toArray() ─ массив объектов
• T[] toArray(t[]) ─ типизированный массив

String[] lines = c.toArray(new String[c.size()]);

• В порядке обхода итератором

• addAll(collection<+E>)

• retainAll(collection<?>)

• containsAll(collection<?>)

• removeAll(collection<?>)

• (Linked)HashSet<E>() ─ пустое множество
• (Linked)HashSet<E>(collection<?>) ─ из коллекции
• (Linked)HashSet<E>(int initialCapacity, float loadFactor?) ─ начальная вместимость и степень заполнения

Set<String> words = new HashSet<String>();
int total = read(args[0], words);
System.out.println("Words total: " + total);
System.out.println("Unique words: " +
    words.size());
dump(words);

• Set.of(elements...)
• Set.copyOf(collection<+E>)

• get(int) ─ чтение
• add(int, e) ─ вставка
• set(int, e) ─ изменение
• remove(int) ─ удаление

• indexOf(object) ─ с начала
• lastIndexOf(object) ─ с конца

• sl = l.subList(1, 4)

• hasNext() / hasPrevious() ─ проверка
• next() / previous() ─ взятие элемента
• nextIndex() / previousIndex() ─ индекса элемента

• add(e) ─ вставка
• set(e) ─ изменение
• remove() ─ удаление

• ensureCapacity(int) ─ увеличить вместимости
• trimToSize() ─ “подгонка” вместимости

• ArrayList<E>(initialCapacity?) ─ пустой список заданной вместимостью
• ArrayList<E>(collection<+E>) ─ копия коллекции

• Быстрый доступ по индексу
• Быстрая вставка и удаление элементов с конца

• Медленная вставка и удаление элементов

• Замена массива
• “Бесконечный” массив
• Стек

List<E> list = new ArrayList<E>();
…
for (int i = list.size() - 1; i >= 0; i--) {
    System.out.println(list.get(i));
}

• LinkedList<E>() ─ пустой список
• LinkedList<E>(collection<?>) ─ копия коллекции

• addFirst(e) – добавить в начало списка
• addLast(e) – добавить в конец списка
• removeFirst() – удалить первый элемент
• removeLast() – удалить последний элемент

• Быстрое добавление и удаление элементов

• Медленный доступ по индексу
• Большое потребление памяти

• Стек
• Очередь
• Дек

List<E> list = new LinkedList<E>();
…
for (ListIterator<E> li = list.listIterator(list.size());
    li.hasPrevious(); )
{
    System.out.println(li.previous());
}

• List.of(elements...)
• List.copyOf(collection<+E>)

• Не могут хранить null
• Различные порядки элементов
• Может быть ограничен размер
• Могу не принять элемент

• add(e) – добавить элемент
  • IllegalStateException
• E element() – первый элемент
  • NoSuchElementException
• E remove() – удалить первый элемент
  • NoSuchElementException

• offer(e) – добавить элемент
• E peek() – первый элемент
• E poll() – удалить первый элемент

• size()
• offer(e)
• peek()
• poll()
• iterator()

• Исключение не дешёвая операция

• Класс ArrayDeque<E> – на массиве
• Класс LinkedList<E> – двусвязный список

• get(object), getOrDefault(object, v) ─ чтение
• put(k, v), putIfAbsent(k, v), replace(k, oldV?, newV) ─ запись
• remove(Object k), remove(Object k, Object v) ─ удаление

• containsKey(object) ─ наличие ключа
• containsValue(object) ─ наличие значения

• size() ─ размер отображения
• isEmpty() ─ проверка на пустоту

• putAll(map<+K, +V>) ─ добавление всех пар

• Set<K> keySet() ─ множество ключей
• Collection<V> values() ─ коллекция значений
• Set<Map.Entry<K, V>> entrySet() ─ множество пар

• K getKey()
• V getValue()
• setValue(v)

• HashMap<K, V>() - пустое
• HashMap<K, V>(map<+K, +V>) ─ копия
• HashMap<K, V>(initialCapacity, loadFactor?) ─ начальная вместимость и степень заполнения

Map<String, Integer> map
    = new HashMap<String, Integer>();
while (scanner.hasNext()) {
    String word = scanner.next();
    Integer count = map.get(word);
    map.put(word, count == null ? 1 : count + 1));
}

for (
    Map.Entry<String, Integer> entry :
        map.entrySet()
) {
    System.out.println(
         entry.getKey() + " " + entry.getValue());
}

• Map.of(k1, v1, k2, v2, k2, ...)
• Map.copyOf(map<+K, +V>)
• Map.ofEntries(entry<+K, +V>...)
• Map.entry(k, v)

• int compareTo(t) ─ естественный порядок

• int compare(t1, t2) ─ внешний порядок

• sgn(x.compareTo(y))) == -sgn(y.compareTo(x))

• x.compareTo(y) == 0 ⇒ sgn(x.compareTo(z))==sgn(y.compareTo(z))

• x.equals(y) == (x.compareTo(y) == 0)

• first() – минимальный элемент
• last() – максимальный элемент

• headSet(e) – элементы < e
• tailSet(e) – e ≤ элементы
• subSet(e1, e2) – e1 ≤ элементы < e2

• pollLast() – max
• lower(e) – max < e
• floor(e) – max ≤ e
• pollFirst() – min
• higher(e) – min > e
• ceiling(e) – min ≥ e
• descendingSet() – вид с обратным порядком

• firstKey() – минимальный ключ
• lastKey() – максимальный ключ

• headMap(k) – ключи < k
• tailMap(k) – k ≤ ключи
• subMap(k1, k2) – k1 ≤ ключи < k2

• {lower|floor|higher|ceiling}Key – поиск ключа
• {lower|floor|higher|ceiling|pollFirst|pollLast}Entry – поиск пары
• descendingMap() – вид с обратным порядком

• Минимальны элемент
• На двоичной куче

SortedSet<T> words = new TreeSet<String>();
read(args[0], words);
dump(words);

SortedSet<T> words = new TreeSet<String>(
    String.CASE_INSENSITIVE_ORDER);
read(args[0], words);
dump(words);

• Простые операции
• Сортировка
• Двоичный поиск
• Поиск минимума и максимума

• fill(list<−T>, t)

• reverse(list<?>)

• copy(list<−T>, list<+T>)

• Генерирует случайную перестановку
• shuffle(list<?>)
• shuffle(list<?>, random)

• Сортировка слиянием

• sort(list<?>) – естественный порядок
• sort(list<T>, comparator<−T>) – внешний порядок

• Найден – индекс элемента
• Не найден – –1 – индекс места вставки

• binarySearch(list<T>, t) – естественный порядок
• binarySearch(list<T>, t, comparator<−T>) – внешний порядок

• min(collection<T>) – естественный порядок
• min(collection<T>, comparator<−T>) – внешний порядок

• max(collection<T>) – естественный порядок
• max(collection<T>, comparator<−T>) – внешний порядок

List<String> list = new ArrayList<String>();
read(args[0], list);
Collections.reverse(list);
Collections.shuffle(list);
Collections.sort(list);
Collections.sort(list,
    String.CASE_INSENSITIVE_ORDER);
Collections.fill(list, "temp");
System.out.println(Collections.min(list));
System.out.println(Collections.min(list,
    String.CASE_INSENSITIVE_ORDER));

• emptySet() – пустое множество
• emptyList() – пустой список
• emptyMap() – пустое отображение

• singleton(t) – множество
• singletonList(t) – список
• singletonMap(k, v) – отображение

• nCopies(count, value) – размножить
• newSetFromMap(map<E, Boolean>) – множество из отображения

• unmodifiableSet(set<+T>) – множество
• unmodifiableSortedSet(sortedSet<+T>) – упорядоченное множество
• unmodifiableList(list<+T>) – список
• unmodifiableMap(map<+T>) – отображение
• unmodifiableSortedMap(sortedMap<+T>) – упорядоченное отображение

• Сортировка
• Двоичный поиск
• Поиск минимума и максимума
• Заполнение
• Преобразование в строку
• ...

• List<T> asList(t...)