Java Collections API

A collection designed for holding elements before processing.
Besides basic Collection operations, queues provide additional insertion,
extraction, and inspection operations.

A Queue with operations that wait for the queue to become nonempty
when retrieving an element and that wait for space to become available
in the queue when storing an element.

A double ended queue, supporting element insertion and removal at both ends.
Extends the Queue interface.

A Deque with operations that wait for the deque to become nonempty
when retrieving an element and wait for space to become available
in the deque when storing an element.
Extends both the Deque and BlockingQueue interfaces.

Skeletal Queue implementation.

An optionally bounded FIFO blocking deque backed by linked nodes.

A bounded FIFO blocking queue backed by an array.

A time-based scheduling queue backed by a priority heap.

An optionally bounded FIFO blocking queue backed by linked nodes.

An unbounded blocking priority queue backed by a priority heap.

Heap implementation of an unbounded priority queue.

A simple rendezvous mechanism
that uses the BlockingQueue interface.

Efficient, resizable array implementation of the Deque interface.

An unbounded first in, first out (FIFO) queue based on linked nodes.

A BlockingQueue in which producers can
wait for consumers to receive elements.

An unbounded TransferQueue backed by linked nodes.

The familiar set abstraction.
No duplicate elements permitted.
May or may not be ordered.
Extends the Collection interface.

Skeletal Set implementation.

A high-performance Set implementation backed by a bit vector.
All elements of each EnumSet instance must be elements of a single enum type.

Hash table implementation of the Set interface.
The best all-around implementation of the Set interface.

Hash table and linked list implementation of the Set interface.
An insertion-ordered Set implementation that runs nearly as fast as HashSet.

A set whose elements are automatically sorted,
either in their natural ordering (see the Comparable interface)
or by a Comparator object provided when a SortedSet instance is created.
Extends the Set interface.

A SortedSet extended with navigation methods
reporting closest matches for given search targets.
A NavigableSet may be accessed and traversed
in either ascending or descending order.

Red-black tree implementation of the NavigableSet interface.

Skips list implementation of the NavigableSet interface.

A Set implementation backed by a copy-on-write array.
This implementation is similar to CopyOnWriteArrayList.
Unlike most Set implementations, the add, remove,
and contains methods require time proportional to the size of the set.
This implementation is well suited to maintaining event-handler lists that must prevent duplicates.

Ordered collection, also known as a sequence.
Duplicates are generally permitted.
Allows positional access.
Extends the Collection interface.

Skeletal List implementation backed by
a random access data store (such as an array).

Skeletal List implementation backed by a
sequential access data store (such as a linked list).

Resizable array implementation of the List interface (an unsynchronized Vector).
The best all-around implementation of the List interface.

Synchronized resizable array implementation of the List interface with additional legacy methods.

The Stack class represents a last-in-first-out (LIFO) stack of objects.

Doubly-linked list implementation of the List interface.
Provides better performance than the ArrayList implementation if elements are frequently inserted or deleted within the list.
Also implements the Deque interface.
When accessed through the Queue interface, LinkedList acts as a FIFO queue.

A List implementation backed by an copy-on-write array.
All mutative operations (such as add, set, and remove) are implemented by making a new copy of the array.
No synchronization is necessary, even during iteration, and iterators are guaranteed never to throw ConcurrentModificationException.
This implementation is well-suited to maintaining event-handler lists (where change is infrequent, and traversal is frequent and potentially time-consuming).

Implementing this interface allows an object
to be the target of the "foreach" statement.

A group of objects.
No assumptions are made about the order of the collection (if any)
or whether it can contain duplicate elements.

Skeletal Collection implementation that is
neither a set nor a list (such as a "bag" or multiset).