LinkedList
- 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.

HashMap - Hash
table implementation of the Map interface (an
unsynchronized Hashtable that supports null keys
and values). The best all-around implementation of the Map
interface.

LinkedHashMap
- Hash table and linked list implementation of the Map
interface. An insertion-ordered Map implementation that
runs nearly as fast as HashMap. Also useful for building
caches (see
removeEldestEntry(Map.Entry) ).

WeakHashMap
- An implementation of the Map interface that stores only
weak
references to its keys. Storing only weak references enables
key-value pairs to be garbage collected when the key is no longer
referenced outside of the WeakHashMap. This class is
the easiest way to use the power of weak references. It is
useful for implementing registry-like data structures, where the
utility of an entry vanishes when its key is no longer reachable by
any thread.

sort(List)
- Sorts a list using a merge sort algorithm, which provides
average case performance comparable to a high quality quicksort,
guaranteed O(n*log n) performance (unlike quicksort), and
stability (unlike quicksort). A stable sort is one that
does not reorder equal elements.

Iterators - Similar to the familiar Enumeration
interface, but more powerful, and with improved method names.

Iterator
- In addition to the functionality of the Enumeration
interface, enables the user to remove elements from the backing
collection with well-defined, useful semantics.

ListIterator
- Iterator for use with lists. In addition to the functionality of
the Iterator interface, supports bidirectional iteration,
element replacement, element insertion, and index retrieval.

Ordering

Comparable
- Imparts a natural ordering to classes that implement it.
The natural ordering can be used to sort a list or maintain order
in a sorted set or map. Many classes were retrofitted to
implement this interface.

Comparator
- Represents an order relation, which can be used to sort a list or
maintain 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.

ConcurrentModificationException - Thrown by iterators
and list iterators if the backing collection is changed
unexpectedly while the iteration is in progress. Also thrown by
sublist views of lists if the backing list is changed
unexpectedly.

Performance

RandomAccess
- Marker interface that lets List implementations
indicate that they support fast (generally constant time) random
access. This lets generic algorithms change their behavior to
provide good performance when applied to either random or
sequential access lists.