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

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

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

• contains(object) ─ одного элемента
• containsAll(collection<?>) ─ всех элементов collection
  • Почему Collection<?>

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

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

• UnsupportedOperationException

public int read(String file, Collection<String> c)
        throws IOException {
    Scanner scanner =
        new Scanner(Paths.get(file), "UTF-8");
    int read = 0;
    while (scanner.hasNext()) {
        read++;
        c.add(scanner.next());
    }
    return read;
}

• Метод 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[]) ─ типизированный массив
• T[] toArray(intFunction<T[]>) ─ типизированный массив

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

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

• iterator()
• size()

• add(e)
• iterator.remove()

• x.equals(x)

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

• x.equals(y) ∧ y.equals(z) ⇒ x.equals(z)

• x.equals(y) не изменяется, если x и y не изменяются

• x.equals(null) == false

• public class Point {
      protected int x;
      protected int y;
      public boolean equals(Object o) {
          if (o instanceof Point) {
              Point that = (Point) o;
              return this.x == that.x && this.y == that.y;
          }
          return false;
      }
  }
  

• public class ColorPoint extends Point {
      protected int c;
      public boolean equals(Object o) {
          if (o instanceof ColorPoint) {
              ColorPoint that = (ColorPoint) o;
              return this.x == that.x && this.y == that.y && this.c == that.c;
          }
          return false;
      }
  }
  

• Несимметричность

• public class ColorPoint extends Point {
      protected int c;
      public boolean equals(Object o) {
          if (o instanceof ColorPoint) {
              ColorPoint that = (ColorPoint) o;
              return this.x == that.x && this.y == that.y && this.c == that.c;
          }
          return super.equals(o);
      }
  }
  

• Нетранзитивность

• Сравнивать объекты только одинакового класса
• Сравнивать как предков
• Послойное сравнение
  • canEquals

• addAll(collection<+E>)

• retainAll(collection<?>)

• containsAll(collection<?>)

• removeAll(collection<?>)

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

• hashCode() не изменяется, если объект не изменяется

• x.equals(y) ⇒ x.hashCode() == y.hashCode()

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);

• EnumSet<E>EnumSet.noneOf(E.class)
• EnumSet<E>EnumSet.allOf(E.class)
• EnumSet<E>EnumSet.of(e1, es...)
• EnumSet<E>EnumSet.copyOf(enumSet<E>)
• EnumSet<E>EnumSet.copyOf(collection<E>)
• EnumSet<E>EnumSet.complementOf(enumSet<E>)

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

• iterator()
• size()

• add(e)
• iterator.remove()

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

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

• sl = l.subList(1, 4)

• Метод list.listIterator(index?)

• 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>)

• Маркерный интерфейс RandomAccess

• get(int)
• size()

• set(int, e)

• add(int, e)
• remove(int)

• listIterator(int) (методы перемещения)
• size()

• set(e)

• add(e)
• remove()

• Не могут хранить 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{First|Last}() — получить
• add{First|Last}(e) — добавить
• remove{First|Last}() — получить и удалить
• reversed() — «развёрнутый» вид

• reversed()
• iterator()

• List<E>
• Deque<E>
• LinkedHashSet<E>
• AbstractSequentialList<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?) ─ начальная вместимость и степень заполнения
• newHashMap<K, V>(int) ─ число элементов

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());
}

• EnumMap<K, V>(K.class)
• EnumMap<K, V>(enumMap<K, V>)
• EnumMap<K, V>(map<K, V>)

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

• entrySet()

• {first|last}Entry() — получить
• put{First|Last}(k, v) — добавить или изменить
• poll{First|Last}() — получить и удалить
• sequenced{EntrySet|KeySet|Values}() — «развёрнутые» пары/ключи/значения
• reversed() — «развёрнутый» вид

• LinkedHashMap

• 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)

• extends Set<K, V> (Java 20−)
• extends SequencedSet<E> (без add{First|Last}(e))

• 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() – вид с обратным порядком

• extends Map<K, V> (Java 20−)
• extends SequencedMap<K, V> (без put{First|Last}(k, v))

• 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<String> words = new TreeSet<>();
read(args[0], words);
dump(words);

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

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

• fill(list<−T>, t)

• reverse(list<?>)

• copy(list<−T>, list<+T>)
• Почему нет copy со смещениями и длинами?
• subList(int, int)

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

• 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));

• emptyList() – список
• empty[Navigable|Sorted]Set() – множество
• empty[Navigable|Sorted]Map() – отображение
• empty[List]Iterator() – итератор

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

• newSetFromMap(map<E, Boolean>) – множество из отображения
• asLifoQueue(deque) – очередь из дека

• checked{List|Queue}(coll, type) — список/очередь
• checked[Sorted|Navigable]Set(set, type) — множество
• checked[Sorted|Navigable]Map(map, keyT, valueT) — отображение
• Бросают ClassCastException

• unmodifiable[Sequenced]Collection(collection<+T>) – [последовательная] коллекция
• unmodifiableList(list<+T>) – список
• unmodifiable[Sorted|Navigable]Set(set, type) — множество
• unmodifiable[Sorted|Navigable]Map(map) — отображение

• nCopies(count, value) – размножить

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

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

• Vector ⇒ ArrayList
• Stack ⇒ ArrayList
• Dictionary ⇒ Map
• Hashtable ⇒ HashMap
• Enumeration ⇒ Iterator