Иногда достаточно сложно для начинающих (особенно если они перешли из других языков программирования) понять, что в коллекции Java хранятся только ссылки/указатели и ничего более. Им кажется, что при вызове add или put объекты действительно хранятся где-то внутри коллекции, это верно только для массивов, когда они работают с примитивными типами, но никак не для коллекций, которые хранят только ссылки. Поэтому очень часто на вопросы собеседований вроде «А можно ли назвать точный размер коллекции ArrayList» начинающие начинают отвечать что-то вроде «Зависит от типа объектов что в них хранятся». Это совершенно не верно, так коллекции никогда не хранят сами объекты, а только ссылки на них. Например, можно в List добавить миллион раз один и то же объект (точнее создать миллион ссылок на один объект).

Интерфейсы коллекций

Название	Описание
Iterable	Интерфейс означающий что у коллекции есть iterator и её можно обойти с помощью for(Type value:collection). Есть почти у всех коллекций (кроме Map)
Collection	Основной интерфейс для большинства коллекций (кроме Map)
List	Список это упорядоченная в порядке добавления коллекция, так же известная как последовательность (sequence). Дублирующие элементы в большинстве реализаций — разрешены. Позволяет доступ по индексу элемента. Расширяет Collection интерфейс.
Set	Интерфейс реализующий работу с множествами (похожими на математические множества), дублирующие элементы запрещены. Может быть, а может и не быть упорядоченным. Расширяет Collection интерфейс.
Queue	Очередь — это коллекция, предназначенная для хранения объектов до обработки, в отличии от обычных операций над коллекциями, очередь предоставляет дополнительные методы добавление, получения и просмотра. Быстрый доступ по индексу элемента, как правило, не содержит. Расширяет Collection интерфейс
Deque	Двухсторонняя очередь, поддерживает добавление и удаление элементов с обоих концов. Расширяет Queue интерфейс.
Map	Работает со соответствием ключ — значение. Каждый ключ соответствует только одному значению. В отличие от других коллекций не расширяет никакие интерфейсы (в том числе Collection и Iterable)
SortedSet	Автоматически отсортированное множество, либо в натуральном порядке (для подробностей смотрите Comparable интерфейс), либо используя Comparator. Расширяет Set интерфейс
SortedMap	Это map'а ключи которой автоматически отсортированы, либо в натуральном порядке, либо с помощью comparator'а. Расширяет Map интерфейс.
NavigableSet	Это SortedSet, к которому дополнительно добавили методы для поиска ближайшего значения к заданному значению поиска. NavigableSet может быть доступен для доступа и обхода или в порядке убывания значений или в порядке возрастания.
NavigableMap	Это SortedMap, к которому дополнительно добавили методы для поиска ближайшего значения к заданному значению поиска. Доступен для доступа и обхода или в порядке убывания значений или в порядке возрастания.

Интерфейсы из пакета java.util.concurrent

Название	Описание
BlockingQueue	Многопоточная реализация Queue, содержащая возможность задавать размер очереди, блокировки по условиях, различные методы, по-разному обрабатывающие переполнение при добавлении или отсутствие данных при получении (бросают exception, блокируют поток постоянно или на время, возвращают false и т.п.)
TransferQueue	Эта многопоточная очередь может блокировать вставляющий поток, до тех пор, пока принимающий поток не вытащит элемент из очереди, таким образом с её помощью можно реализовывать синхронные и асинхронные передачи сообщений между потоками
BlockingDeque	Аналогично BlockingQueue, но для двухсторонней очереди
ConcurrentMap	Интерфейс, расширяет интерфейс Map. Добавляет ряд новых атомарных методов: putIfAbsent, remove, replace, которые позволяют облегчить и сделать более безопасным многопоточное программирование.
ConcurrentNavigableMap	Расширяет интерфейс NavigableMap для многопоточного варианта

Если вам интересны более подробная информация о интерфейсах и коллекциях из java.util.concurrent советую
прочитать вот эту статью.

Тип	Однопоточные	Многопоточные
Lists	ArrayList — основной список, основан на массиве LinkedList — полезен лишь в некоторых редких случаях Vector — устарел	CopyOnWriteArrayList — редкие обновления, частые чтения
Queues / Deques	ArrayDeque — основная реализация, основан на массиве Stack — устарел PriorityQueue — отсортированная очередь	ArrayBlockingQueue — блокирующая очередь ConcurrentLinkedDeque / ConcurrentLinkedQueue — очередь на связанных нодах DelayQueue — очередь с задержкой для каждого элемента LinkedBlockingDeque / LinkedBlockingQueue — блокирующая очередь на связанных нодах LinkedTransferQueue — может служить для передачи элементов PriorityBlockingQueue — многопоточная PriorityQueue SynchronousQueue — простая многопоточная очередь
Maps	HashMap — основная реализация EnumMap — enum в качестве ключей Hashtable — устарел IdentityHashMap — ключи сравниваются с помощью == LinkedHashMap — сохраняет порядок вставки TreeMap — сортированные ключи WeakHashMap — слабые ссылки, полезно для кешей	ConcurrentHashMap — основная многопоточная реализация ConcurrentSkipListMap — отсортированная многопоточная реализация
Sets	HashSet — основная реализация множества EnumSet — множество из enums BitSet* — множество битов LinkedHashSet — сохраняет порядок вставки TreeSet — отсортированные set	ConcurrentSkipListSet — отсортированный многопоточный set CopyOnWriteArraySet — редкие обновления, частые чтения

* — на самом деле, BitSet хоть и называется Set'ом, интерфейс Set не наследует.

Универсальные коллекции общего назначения, которые признаны устаревшими (legacy)

Имя	Описание
Hashtable	Изначально задумывался как синхронизированный аналог HashMap, когда ещё не было возможности получить версию коллекции используя Collecions.synchronizedMap. На данный момент как правило используют ConcurrentHashMap. HashTable более медленный и менее потокобезопасный чем синхронный HashMap, так как обеспечивает синхронность на уровне отдельных операций, а не целиком на уровне коллекции.
Vector	Раньше использовался как синхронный вариант ArrayList, однако устарел по тем же причинам что и HashTable.
Stack	Раньше использовался как для построения очереди, однако поскольку построен на основе Vector, тоже считается морально устаревшим.

Специализированные коллекции, построенные на устаревших (legacy) коллекциях

Имя	Основан на	Описание
Properties	Hashtable	Как структура данных, построенная на Hashtable, Properties довольно устаревшая конструкция, намного лучше использовать Map, содержащий строки. Подробнее почему Properties не рекомендуется использовать можно найти в этом обсуждении.
UIDefaults	Hashtable	Коллекция, хранящая настройки по умолчанию для Swing компонент

Универсальные коллекции общего назначения, реализующие List:

Название	Основан на	Описание	Размер*
ArrayList	List	Реализация List интерфейса на основе динамически изменяемого массива. В большинстве случаев, лучшая возможная реализация List интерфейса по потреблению памяти и производительности. В крайне редких случаях, когда требуются частые вставки в начало или середину списка с очень малым количеством перемещений по списку, LinkedList будет выигрывать в производительности (но советую в этих случаях использовать TreeList от apache). Если интересны подробности ArrayList советую посмотреть эту статью.	4*N
LinkedList	List	Реализация List интерфейса на основе двухстороннего связанного списка, то есть когда каждый элемент, указывает на предыдущий и следующий элемент. Как правило, требует больше памяти и хуже по производительности, чем ArrayList, имеет смысл использовать лишь в редких случаях когда часто требуется вставка/удаление в середину списка с минимальными перемещениями по списку (но советую в этих случаях использовать TreeList от apache).Так же реализует Deque интерфейс. При работе через Queue интерфейс, LinkedList действует как FIFO очередь. Если интересны подробности LinkedList советую посмотреть эту статью.	24*N

Коллекции из пакета java.util.concurrent

Название	Основан на	Описание
CopyOnWriteArrayList	List	Реализация List интерфейса, аналогичная ArrayList, но при каждом изменении списка, создается новая копия всей коллекции. Это требует очень больших ресурсов при каждом изменении коллекции, однако для данного вида коллекции не требуется синхронизации, даже при изменении коллекции во время итерирования.

Узкоспециализированные коллекции на основе List.

Название	Основан на	Описание
RoleList	ArrayList	Коллекция для хранения списка ролей (Roles). Узкоспециализированная коллекция основанная на ArrayList с несколькими дополнительными методами
RoleUnresolvedList	ArrayList	Коллекция для хранения списка unresolved ролей (Unresolved Roles). Узкоспециализированная коллекция основанная на ArrayList с несколькими дополнительными методами
AttributeList	ArrayList	Коллекция для хранения атрибутов MBean. Узкоспециализированная коллекция основанная на ArrayList с несколькими дополнительными методами

* — размер дан в байтах для 32 битных систем и Compressed Oops, где N это capacity списка

Название	Основан на	Описание	Размер*
HashSet	Set	Реализация Set интерфейса с использованием хеш-таблиц. В большинстве случаев, лучшая возможная реализация Set интерфейса.	32*S + 4*C
LinkedHashSet	HashSet	Реализация Set интерфейса на основе хеш-таблиц и связанного списка. Упорядоченное по добавлению множество, которое работает почти так же быстро как HashSet. В целом, практически тоже самое что HashSet, только порядок итерирования по множеству определен порядком добавления элемента во множество в первый раз.	40 * S + 4*C
TreeSet	NavigableSet	Реализация NavigableSet интерфейса, используя красно-черное дерево. Отсортировано с помощью Comparator или натурального порядка, то есть обход/итерирование по множеству будет происходить в зависимости от правила сортировки. Основано на TreeMap, так же как HashSet основан на HashMap	40 * S
EnumSet	Set	Высокопроизводительная реализация Set интерфейса, основанная на битовом векторе. Все элементы EnumSet объекта должны принадлежать к одному единственному enum типу	S/8

* — размер дан в байтах для 32 битных систем и Compressed Oops, где С это capacity списка, S это size списка

Узкоспециализированные коллекции на основе Set

Название	Основан на	Описание
JobStateReasons	HashSet	Коллекция для хранения информации о заданиях печати (print job's attribute set). Узкоспециализированная коллекция основанная на HashSet с несколькими дополнительными методами

Коллекции из пакета java.util.concurrent

Название	Основан на	Описание
CopyOnWriteArraySet	Set	Аналогично CopyOnWriteArrayList при каждом изменении создает копию всего множества, поэтому рекомендуется при очень редких изменениях коллекции и требованиях к thread-safe
ConcurrentSkipListSet	Set	Является многопоточным аналогом TreeSet

Универсальные коллекции общего назначения, реализующие Map:

Название	Основан на	Описание	Размер*
HashMap	Map	Реализация Map интерфейса с помощью хеш-таблиц (работает как не синхронная Hashtable, с поддержкой ключей и значений равных null). В большинстве случаев лучшая по производительности и памяти реализация Map интерфейса. Если интересны подробности устройства HashMap советую посмотреть эту статью.	32 * S + 4*C
LinkedHashMap	HashMap	Реализация Map интерфейса, на основе хеш-таблицы и связного списка, то есть ключи в Map'е хранятся и обходятся во порядке добавления. Данная коллекция работает почти так же быстро как HashMap. Так же она может быть полезна для создания кешей (смотрите removeEldestEntry(Map.Entry) ). Если интересны подробности устройства LinkedHashMap советую посмотреть эту статью.	40 * S + 4*C
TreeMap	NavigableMap	Реализация NavigableMap с помощью красно-черного дерева, то есть при обходе коллекции, ключи будут отсортированы по порядку, так же NavigableMap позволяет искать ближайшее значение к ключу.	40 * S
WeakHashMap	Map	Аналогична HashMap, однако все ключи являются слабыми ссылками (weak references), то есть garbage collected может удалить объекты ключи и объекты значения, если других ссылок на эти объекты не существует. WeakHashMap один из самых простых способов для использования всех преимуществ слабых ссылок.	32 * S + 4*C
EnumMap	Map	Высокопроизводительная реализация Map интерфейса, основанная на простом массиве. Все ключи в этой коллекции могут принадлежать только одному enum типу.	4*C
IdentityHashMap	Map	Identity-based Map, так же как HashMap, основан на хеш-таблице, однако в отличии от HashMap он никогда не сравнивает объекты на equals, только на то является ли они реально одиним и тем же объектом в памяти. Это во-первых, сильно ускоряет работу коллекции, во-вторых, полезно для защиты от «spoof attacks», когда сознательно генерируется объекты equals другому объекту. В-третьих, у данной коллекции много применений при обходе графов (таких как глубокое копирование или сериализация), когда нужно избежать обработки одного объекта несколько раз.	8*C

* — размер дан в байтах для 32 битных систем и Compressed Oops, где С это capacity списка, S это size списка

Коллекции из пакета java.util.concurrent

Название	Основан на	Описание
ConcurrentHashMap	ConcurrentMap	Многопоточный аналог HashMap. Все данные делятся на отдельные сегменты и блокируются только отдельные сегменты при изменении, что позволяет значительно ускорить работу в многопоточном режиме. Итераторы никогда не кидают ConcurrentModificationException для данного вида коллекции
ConcurrentSkipListMap	ConcurrentNavigableMap	Является многопоточным аналогом TreeMap

Название	Основан на	Описание	Размер*
ArrayDeque	Deque	Эффективная реализация Deque интерфейса, на основе динамического массива, аналогичная ArrayList	6*N
LinkedList	Deque	Реализация List и Deque интерфейса на основе двухстороннего связанного списка, то есть когда каждый элемент, указывает на предыдущий и следующий элемент.При работе через Queue интерфейс, LinkedList действует как FIFO очередь.	40*N
PriorityQueue	Queue	Неограниченная priority queue, основанная на куче (нeap). Элементы отсортированы в натуральном порядке или используя Comparator. Не может содержать null элементы.

* — размер дан в байтах для 32 битных систем и Compressed Oops, где С это capacity списка, S это size списка

Многопоточные Queue и Deque, который определены в java.util.concurrent, требуют отдельной статьи, поэтому здесь приводить их не буду, если вам интересна информация о них советую прочитать вот эту статью

Название	Описание	Размер*
BitSet	Несмотря на название, BitSet не реализует интерфейс Set. BitSet служит для компактной записи массива битов.	N / 8

Алгоритмы- В классе Collections содержится много полезных статистических методов.
Для работы с любой коллекцией:

Метод	Описание
frequency(Collection, Object)	Возвращает количество вхождений данного элемента в указанной коллекции
disjoint(Collection, Collection)	Возвращает true, если в двух коллекциях нет общих элементов
addAll(Collection<? super T>, T...)	Добавляет все элементы из указанного массива (или перечисленные в параметрах) в указанную коллекцию
min(Collection)	Возвращение минимального элемента из коллекции
max(Collection)	Возвращение максимального элемента из коллекции

Для работы со списками:

Метод	Описание
sort(List)	Сортировка с использованием алгоритма сортировки соединением (merge sort algorithm), производительность которой в большинстве случаев близка к производительности быстрой сортировки (high quality quicksort), гарантируется O(n*log n) производительность (в отличии от quicksort), и стабильность (в отличии от quicksort). Стабильная сортировка это такая которая не меняет порядок одинаковых элементов при сортировке
binarySearch(List, Object)	Поиск элемента в списке (list), используя binary search алгоритм.
reverse(List)	Изменение порядка всех элементов списка (list)
shuffle(List)	Перемешивание всех элементов в списке в случайном порядке
fill(List, Object)	Переписывание каждого элемента в списке каким-либо значением
copy(List dest, List src)	Копирование одного списка в другой
rotate(List list, int distance)	Передвигает все элементы в списке на указанное расстояние
replaceAll(List list, Object oldVal, Object newVal)	Заменяет все вхождения одного значения на другое
indexOfSubList(List source, List target)	Возвращает индекс первого вхождения списка target в список source
lastIndexOfSubList(List source, List target)	Возвращает индекс последнего вхождения списка target в список source
swap(List, int, int)	Меняет местами элементы, находящиеся на указанных позициях

В Java 8 так же появился такой способ работы с коллекциями как stream Api, но мы рассмотрим примеры его использование далее в разделе 5.

Коллекция	Описание внутреннего устройства
ArrayList	Данная коллекция лишь настройка над массивом + переменная хранящая size списка. Внутри просто массив, который пересоздается каждый раз когда нет места для добавления нового элемента. В случае, добавления или удаления элемента внутри коллекции весь хвост сдвигается в памяти на новое место. К счастью, копирование массива при увеличении емкости или при добавлении/удалении элементов производится быстрыми нативными/системными методами. Если интересны подробности советую посмотреть эту статью.
LinkedList	Внутри коллекции используется внутренний класс Node, содержащий ссылку на предыдущий элемент, следующий элемент и само значение элемента. В самом инстансе коллекции хранится размер и ссылки на первый и последний элемент коллекции. Учитывая что создание объекта дорогое удовольствие для производительности и затратно по памяти, LinkedList чаще всего работает медленно и занимает намного больше памяти чем аналоги. Обычно ArrayList, ArrayDequery лучшее решение по производительности и памяти, но в некоторых редких случаях (частые вставки в середину списка с редкими перемещениями по списку), он может быть быть полезен (но в этом случае полезнее использовать TreeList от apache). Если интересны подробности советую посмотреть эту статью.
HashMap	Данная коллекция построена на хеш-таблице, то есть внутри коллекции находится массив внутреннего класса (buket) Node равный capacity коллекции. При добавлении нового элемента вычисляться его хеш-функция, делиться на capacity HashMap по модулю и таким образом вычисляется место элемента в массиве. Если на данном месте ещё не храниться элементов создается новый объект Node с ссылкой на добавляемый элемент и записывается в нужное место массива. Если на данном месте уже есть элемент/ы (происходит хеш-коллизия), то так Node является по сути односвязным списком, то есть содержит ссылку на следующий элемент, то можно обойти все элементы в списке и проверить их на equals добавляемому элементу, если этот такого совпадение не найдено, то создается новый объект Node и добавляется в конец списка. В случае, если количество элементов в связном списке (buket) становится более 8 элементов, вместо него создается бинарное дерево. Подробнее о хеш таблицах смотрите вики (в HashMap используется метод цепочек для разрешения коллизий). Если интересны подробности устройства HashMap советую посмотреть эту статью.
HashSet	HashSet это просто HashMap, в которую записывается фейковый объект Object вместо значения, при этом имеет значение только ключи. Внутри HashSet всегда хранится коллекция HashMap.
IdentityHashMap	IdentityHashMap это аналог HashMap, но при этом не требуется элементы проверять на equals, так как разными считаются любые два элементы. указывающие на разные объекты. Благодаря этому удалось избавится от внутреннего класса Node, храня все данные в одном массиве, при этом при коллизиях ищется подходящая свободная ячейка до тех пор пока не будет найдена (метод открытой адресации).Подробнее о хеш таблицах смотрите вики (в IdentityHashMap используется метод открытой адресации для разрешения коллизий)
LinkedHashMap/LinkedHashSet	Внутренняя структура практически такая же как при HashMap, за исключением того что вместо внутреннего класса Node, используется TreeNode, которая знает предыдущее и следующее значение, это позволяет обходить LinkedHashMap по порядку добавления ключей. По сути, LinkedHashMap = HashMap + LinkedList. Если интересны подробности устройства LinkedHashMap советую посмотреть эту статью.
TreeMap/TreeSet	Внутренняя структура данных коллекций построена на сбалансированным красно-черным деревом, подробнее о нем можно почитать в вики
WeakHashMap	Внутри все организовано практически как в HashMap, за исключением что вместо обычных ссылок используются WeakReference и есть отдельная очередь ReferenceQueue, необходимая для удаления WeakEntries
EnumSet/EnumMap	В EnumSet и EnumMap в отличие от HashSet и HashMap используются битовые векторы и массивы для компактного хранения данных и ускорения производительности. Ограничением этих коллекций является то что EnumSet и EnumMap могут хранить в качестве ключей только значения одного Enum'а.

Давайте посмотрим какие ещё полезные сущности содержит официальный гайд по коллекциями
1) Wrapper implementations – Обертки для добавления функциональности и изменения поведения других реализаций. Доступ исключительно через статистические методы.

• Collections.unmodifiableInterface– Обертка для создания не модифицируемой коллекции на основе указанной, при любой попытки изменения данной коллекции будет выкинут UnsupportedOperationException
  
• Collections.synchronizedInterface– Создания синхронизированной коллекции на основе указанной, до тех пор пока доступ к базовой коллекции идет через коллекцию-обертку, возвращенную данной функцией, потокобезопасность гарантируется.
  
• Collections.checkedInterface – Возвращает коллекцию с проверкой правильности типа динамически
  (во время выполнения), то есть возвращает type-safe view для данной коллекции, который
  выбрасывает ClassCastException при попытке добавить элемент ошибочного типа. При использовании
  механизма generic'ов JDK проверяет на уровне компиляции соответствие типов, однако этот механизм
  можно обойти, динамическая проверка типов не позволяет воспользоваться этой возможностью.
  
  

2) Adapter implementations – данная реализация адаптирует один интерфейс коллекций к другому

• newSetFromMap(Map) – Создает из любой реализации Set интерфейса реализацию Map интерфейса.
• asLifoQueue(Deque) - возвращает view из Deque в виде очереди работающей по принципу Last In First Out (LIFO).
  

3) Convenience implementations – Высокопроизводительные «мини-реализации» для интерфейсов коллекций.

• Arrays.asList – Позволяет отобразить массив как список (list)
• emptySet, emptyList и emptyMap – возвращает пустую не модифицированную реализацию empty set, list, or
  map
  
• singleton, singletonList и singletonMap – возвращает не модифицируемый set, list или map, содержащий один заданный объект (или одно связь ключ-значение)
  
• nCopies – Возвращает не модифицируемый список, содержащий n копий указанного объекта

4) Абстрактные реализации интерфейсов — Реализация общих функций (скелета коллекций) для упрощения создания конкретных реализаций коллекций.

• AbstractCollection – Абстрактная реализация интерфейса Collection для коллекций, которые не являются ни множеством, ни списком (таких как «bag» или multiset).
  
• AbstractSet — Абстрактная реализация Set интерфейса.
• AbstractList – Абстрактная реализация List интерфейса для списков, позволяющих позиционный доступ (random access), таких как массив.
  
• AbstractSequentialList – Абстрактная реализация List интерфейса, для списков, основанных на последовательном доступе (sequential access), таких как linked list.
  
• AbstractQueue — Абстрактная Queue реализация.
• AbstractMap — Абстрактная Map реализация.

4) Инфраструктура

• Iterators – Похожий на обычный Enumeration интерфейс, но с большими возможностями.
• Iterator – Дополнительно к функциональности Enumeration интерфейса, который включает возможности по удалению элементов из коллекции.
  
• ListIterator – это Iterator который используется для lists, который добавляет к функциональности обычного Iterator интерфейса, такие как итерация в обе стороны, замена элементов, вставка элементов, получение по индексу.
  

5) Ordering

• Comparable — Определяет натуральный порядок сортировки для классов, которые реализуют их. Этот порядок может быть использован в методах сортировки или для реализации sorted set или map.
  
• Comparator — Represents an order relation, which can be used to sort a list or maintin order in a sorted set or map. Can override a type's natural ordering or order objects of a type that does not implement the Comparable interface.
  

6) Runtime exceptions

• UnsupportedOperationException – Это ошибка выкидывается когда коллекция не поддерживает операцию, которая была вызвана.
  
• ConcurrentModificationException – Выкидывается iterators или list iterators, если коллекция на которой он основан была неожиданно (для алгоритма) изменена во время итерирования, также выкидывается во views основанных на списках, если главный список был неожиданно изменен.
  

7) Производительность

• RandomAccess — Интерфейс-маркер, который отмечает списки позволяющие быстрый (как правило за константное время) доступ к элементу по позиции. Это позволяет генерировать алгоритмы учитывающие это поведение для выбора последовательного и позиционного доступа.

8) Утилиты для работы с массивами

• Arrays – Набор статических методов для сортировки, поиска, сравнения, изменения размера, получения хеша для массива. Так же содержит методы для преобразования массива в строка и заполнения массива примитивами или объектами.

Stream API это новый способ работать со структурами данных в функциональном стиле. Чаще всего с помощью stream в Java 8 работают с коллекциями, но на самом деле этот механизм может использоваться для самых различных данных.

Stream Api позволяет писать обработку структур данных в стиле SQL, то если раньше задача получить сумму всех нечетных чисел из коллекции решалась следующим кодом:

        Integer sumOddOld = 0; 
        for(Integer i: collection) {
            if(i % 2 != 0) {
                sumOddOld += i;
            }
        }

То с помощью Stream Api можно решить такую задачу в функциональном стиле:

       Integer sumOdd = collection.stream().filter(o -> o % 2 != 0).reduce((s1, s2) -> s1 + s2).orElse(0);

Более того, Stream Api позволяет решать задачу параллельно лишь изменив stream() на parallelStream() без всякого лишнего кода, т.е.

       Integer sumOdd = collection.parallelStream().filter(o -> o % 2 != 0).reduce((s1, s2) -> s1 + s2).orElse(0);

Уже делает код параллельным, без всяких семафоров, синхронизаций, рисков взаимных блокировок и т.п.

Перечислим несколько способов создать стрим

Способ создания стрима	Шаблон создания	Пример
1. Классический: Создание стрима из коллекции	collection.stream()	Collection<String> collection = Arrays.asList("a1", "a2", "a3"); Stream<String> streamFromCollection = collection.stream();
2. Создание стрима из значений	Stream.of(значение1,… значениеN)	Stream<String> streamFromValues = Stream.of("a1", "a2", "a3");
3. Создание стрима из массива	Arrays.stream(массив)	String[] array = {"a1","a2","a3"}; Stream<String> streamFromArrays = Arrays.stream(array);
4. Создание стрима из файла (каждая строка в файле будет отдельным элементом в стриме)	Files.lines(путь_к_файлу)	Stream<String> streamFromFiles = Files.lines(Paths.get("file.txt"))
5. Создание стрима из строки	«строка».chars()	IntStream streamFromString = "123".chars()
6. С помощью Stream.builder	Stream.builder().add(...)....build()	Stream.builder().add("a1").add("a2").add("a3").build()
7. Создание параллельного стрима	collection.parallelStream()	Stream<String> stream = collection.parallelStream();
8. Создание бесконечных стрима с помощью Stream.iterate	Stream.iterate(начальное_условие, выражение_генерации)	Stream<Integer> streamFromIterate = Stream.iterate(1, n -> n + 1)
9. Создание бесконечных стрима с помощью Stream.generate	Stream.generate(выражение_генерации)	Stream<String> streamFromGenerate = Stream.generate(() -> "a1")

Общее правило: у stream'a может быть сколько угодно вызовов конвейерных вызовов и в конце один терминальный, при этом все конвейерные методы выполняются лениво и пока не будет вызван терминальный метод никаких действий на самом деле не происходит, так же как создать объект Thread или Runnable, но не вызвать у него start.

В целом, этот механизм похож на конструирования SQL запросов, может быть сколько угодно вложенных Select'ов и только один результат в итоге. Например, в выражении collection.stream().filter((s) -> s.contains(«1»)).skip(2).findFirst(), filter и skip — конвейерные, а findFirst — терминальный, он возвращает объект Optional и это заканчивает работу со stream'ом.

Метод stream	Описание	Пример
filter	Отфильтровывает записи, возвращает только записи, соответствующие условию	collection.stream().filter(«a1»::equals).count()
skip	Позволяет пропустить N первых элементов	collection.stream().skip(collection.size() — 1).findFirst().orElse(«1»)
distinct	Возвращает стрим без дубликатов (для метода equals)	collection.stream().distinct().collect(Collectors.toList())
map	Преобразует каждый элемент стрима	collection.stream().map((s) -> s + "_1").collect(Collectors.toList())
peek	Возвращает тот же стрим, но применяет функцию к каждому элементу стрима	collection.stream().map(String::toUpperCase).peek((e) -> System.out.print("," + e)). collect(Collectors.toList())
limit	Позволяет ограничить выборку определенным количеством первых элементов	collection.stream().limit(2).collect(Collectors.toList())
sorted	Позволяет сортировать значения либо в натуральном порядке, либо задавая Comparator	collection.stream().sorted().collect(Collectors.toList())
mapToInt, mapToDouble, mapToLong	Аналог map, но возвращает числовой стрим (то есть стрим из числовых примитивов)	collection.stream().mapToInt((s) -> Integer.parseInt(s)).toArray()
flatMap, flatMapToInt, flatMapToDouble, flatMapToLong	Похоже на map, но может создавать из одного элемента несколько	collection.stream().flatMap((p) -> Arrays.asList(p.split(",")).stream()).toArray(String[]::new)

Метод stream	Описание	Пример
findFirst	Возвращает первый элемент из стрима (возвращает Optional)	collection.stream().findFirst().orElse(«1»)
findAny	Возвращает любой подходящий элемент из стрима (возвращает Optional)	collection.stream().findAny().orElse(«1»)
collect	Представление результатов в виде коллекций и других структур данных	collection.stream().filter((s) -> s.contains(«1»)).collect(Collectors.toList())
count	Возвращает количество элементов в стриме	collection.stream().filter(«a1»::equals).count()
anyMatch	Возвращает true, если условие выполняется хотя бы для одного элемента	collection.stream().anyMatch(«a1»::equals)
noneMatch	Возвращает true, если условие не выполняется ни для одного элемента	collection.stream().noneMatch(«a8»::equals)
allMatch	Возвращает true, если условие выполняется для всех элементов	collection.stream().allMatch((s) -> s.contains(«1»))
min	Возвращает минимальный элемент, в качестве условия использует компаратор	collection.stream().min(String::compareTo).get()
max	Возвращает максимальный элемент, в качестве условия использует компаратор	collection.stream().max(String::compareTo).get()
forEach	Применяет функцию к каждому объекту стрима, порядок при параллельном выполнении не гарантируется	set.stream().forEach((p) -> p.append("_1"));
forEachOrdered	Применяет функцию к каждому объекту стрима, сохранение порядка элементов гарантирует	list.stream().forEachOrdered((p) -> p.append("_new"));
toArray	Возвращает массив значений стрима	collection.stream().map(String::toUpperCase).toArray(String[]::new);
reduce	Позволяет выполнять агрегатные функции на всей коллекцией и возвращать один результат	collection.stream().reduce((s1, s2) -> s1 + s2).orElse(0)

Обратите внимание методы findFirst, findAny, anyMatch это short-circuiting методы, то есть обход стримов организуется таким образом чтобы найти подходящий элемент максимально быстро, а не обходить весь изначальный стрим.

Метод stream	Описание	Пример
sum	Возвращает сумму всех чисел	collection.stream().mapToInt((s) -> Integer.parseInt(s)).sum()
average	Возвращает среднее арифметическое всех чисел	collection.stream().mapToInt((s) -> Integer.parseInt(s)).average()
mapToObj	Преобразует числовой стрим обратно в объектный	intStream.mapToObj((id) -> new Key(id)).toArray()

Метод stream	Описание
isParallel	Узнать является ли стрим параллельным
parallel	Вернуть параллельный стрим, если стрим уже параллельный, то может вернуть самого себя
sequential	Вернуть последовательный стрим, если стрим уже последовательный, то может вернуть самого себя

1. How can we make sure main() is the last thread to finish in Java Program?
2. Как thread могут взаимодействовать с друг другом?
3. Why thread communication methods wait(), notify() and notifyAll() are in Object class?
4. Why wait(), notify() and notifyAll() methods have to be called from synchronized method or block?
5. Почему Thread sleep() и yield() методы статические?
6. Как обеспечить thread safety в Java?
7. Что такое volatile keyword в Java
8. Что предпочтительнее Synchronized метод или Synchronized блок?
9. Что такое ThreadLocal?
10. Что такое Thread Group? Стоит ли их использовать?
11. Что такое Java Thread Dump, Как получить Java Thread dump программы?
12. Что такое Java Timer Class? Как запустить task после определенного интервала времени?
13. Что такое Thread Pool? Как создать Thread Pool в Java?
14. Что произойдет если не override метод run() у класса Thread ?

Processes and threads — разница в том что процессы это независимые приложения (управляются ОС), thread это отдельные легковесные нити для параллельного выполнения в Java (управляются JVM и программистом).

Преимущества multi-threaded программирования — правильно написанная multi-threaded приложение работает быстрее за счет использования нескольких процессоров и процессор не простаивает пока один из потоков ожидает получения ресурсов.

daemon thread — thread, который работает в фоновом режиме и JVM не требуется ждать его окончания, чтобы завершить работу. Можно сделать любой thread демоном используя setDaemon(true), но этот метод должен вызваться до запуска thread с помощью start.

ThreadGroup — устаревший API, который предоставляет информацию о группе потоков. Сейчас не рекомендуется к использованию.
Java Thread Dump — получение информации о состоянии всех потоков JVM и поиска deadlock ситуаций или других проблем с многопоточностью. Есть много способов генерации Java Thread Dump, например в Java 8 можно сгененерить с помощью команды jcmd PID имя_файла_для_дампа или kill -3 PID, либо с помощью любого профайлера (VisualVM, jstack и т.д.)

Способы создания thread в Java SE:

1. Создать класс, реализующий Runnable интерфейс, реализовать метод run и запустить thread методом start, обратите внимание вызвать метод run неправильно, в этом случае не будет создан новый thread (хотя он отработает).

2. Создать класс-наследника от класса Thread, также переопределить метод run и запустить thread методом start. В отличии от способа 1, класс Thread предоставляет ряд уже определенных методов, однако реализация интерфейса дает больше гибкости (так как множественное наследование в Java невозможно),

3. Использовать Executors, который предоставляет высокоуровневый аналог способов 1-2.

Методы работы с Thread

1. sleep — останавливает выполнение на указанное время, либо до момента когда Thread не был прерван,

2. interrupt — посылает сигнал в Thread, о том что тот должен быть прекращен (мягкое прерывание потока), поток должен поддерживать обработку данного сигнала (опрашивая периодически флаг Thread.interrupted),

3. join — ждет окончания другого потока или сигнала остановки треда,

4. synchronized — ключевое слово перед методами либо блок synchronized(ссылка) {...}

5. wait — остановка треда и ожидания вызова notify или notifyAll.

6. stop (deprecated) — немедленная остановка треда, крайне не рекомендуется использовать, так как состояние общих переменных может оказаться в некорректном состоянии.

7. suspend (deprecated) и resume (deprecated) — временная остановка потока и его восстановление. Не рекомендуется использовать так как очень часто это приводит к deadlock«у (ресурсы при временной остановки остаются заблокированными)

8. setUncaughtExceptionHandler — возможность добавить обработчик исключений в данный поток.

Особые переменные для thread:

ThreadLocal — переменная локальная только для одного thread'а, каждый thread будет видеть свое значение.
volatile — ключевое слово, которое отмечает переменные, которые все потоки читают из памяти (heap) и не кэшируют. Это не решает все проблемы синхронизации, однако обычные переменные потоки имеют право за кэшировать и вообще не обновлять долгое время. Для более надежной работы с несколькими thread'ами стоит использовать Atomic переменные или блоки синхронизации.

Atomic операции — операции которые выполняются или не выполняются целиком.

Следующие операции atomic:

1. Чтение и запись ссылок и примитивных типов (кроме long и double)

2. Чтение и запись всех переменных отмеченных как volatile (так как запись и чтение выполняется как happens-before relationship, то есть в гарантированном порядке),

Atomic переменные для простого способа создания переменных общих для разных тредов с минимизаций синхронизации и ошибок. Подробнее см javadoc

Проблемы при выполнении у многопоточных приложений (liveness problem):

1. Deadlock — блокировка двух разных ресурсов двумя тредами с бесконечным ожиданием освобождения,

2, Starvation — один из потоков блокирует часто используемый ресурс на долгое время заставляя остальные потоки ждать освобождения

3. Livelock — когда два потока освобождают и занимают одни и те же ресурсы в ответ на действия друг друга, при этом не могут занять все необходимые ресурсы и продолжить выполнения.

Для создания неизменяемых объектов требуется придерживаться следующих правил:

1. Не предоставлять „setter“ методов, все поля должны быть final и private,

2. Не позволять наследникам переопределять методы, простейший путь определить класс как final. Более сложный путь определить конструктор как private и создать объекты с помощью factory метода.

3. Поля, включая поля с ссылками на mutable objects не должны позволять изменения:

4. Не предоставлять методов по изменению mutable объектов,.

5. Не отдавать ссылок на mutable объекты, при необходимости создавать копии и передавать копии объектов.

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

Основные виды:

1. Task scheduling framework ( Executor) — интерфейс для запуска заданий в новом треде с запуском по расписанию, управлением асинхорными тасками и т.п.

2. ForkJoinPool — класс, реализующий Executors и ExecutorService для реализации многопоточных стримов и т.п. Он разработан для для эффективного распараллеливания большого количества небольших по времени задач, используя пул тредов (используется технология work-stealing).

3. Lock объекты — удобный способ блокировки объектов и передачи данных между тредами,

4. Executors определяет высокоуровневый способ создания и управления тредами с помощью пула объектов,

5. Многопоточные коллекции — коллекции, работающие в многопоточном приложении (Concurrent Collection, BlockingQueue, Если вам интересны более подробная информация о интерфейсах и коллекциях из java.util.concurrent советую прочитать раздел коллекции этой статьи или вот эту статью.),

6. Atomic переменные для простого способа создания переменных общих для разных тредов с минимизаций синхронизации и ошибок. Подробнее см javadoc

7. ThreadLocalRandom (с JDK 7) предоставляет эффективный способ создания псевдослучайных чисел для многопоточных программ.

• Можно ли указывать unchecked исключения в секции throws?
• Что будет, если в секции throws одно и то же исключение указано несколько раз?
• Можно ли смешивать checked и unchecked исключения?
• В чем отличие checked и unchecked исключений?
• В чем отличие Exception и Error?
• Самом любимый и нелюбимый Exception?
• Можно ли перехватить Error или Throwable?

1. Что такое String в Java? String — это тип данных?
2. Каковы различные способы создания String ?
3. Как мы можем сделать строчный верхний регистр или нижний регистр?
4. Что такое метод SubSequence у класса String?
5. Как сравнить две строки в java-программе?
6. Как преобразовать строку в char и наоборот?
7. Как преобразовать String в массив байтов и наоборот?
8. Можно ли использовать строку в switch операторе?
9. Разница между String, StringBuffer и StringBuilder?
10. Почему String immutable и final в Java
11. Как разделить строку в java?
12. Почему массив Char предпочтительнее String для хранения пароля?
13. Как вы проверяете, равны ли две строки в Java?
14. Что такое String Pool?
15. Что делает метод string ()?
16. Строка является потокобезопасной в Java?
17. Почему String является популярным ключом HashMap на Java?