To illustrate, I will use solid lines to denote 'extends' in Java, and dash lines to denote 'implements' in Java. The way to use my note is to first go to the diagram for the specific class or interface, then read the brief blurb that'll remind you what the class or interface is about for you to choose the right data structure.

## Collections<E>

**Collections Interfaces:**

*Set<E>*A collection that contains no duplicate elements.

*SortedSet<E>*A Set that provides ordering on its elements using their natural ordering, or by a Comparator provided at set creation time.

*NavigableSet<E>*A SortedSet with extra navigation methods reporting closest matches for given search targets. For example, methods lower(), floor(), ceiling(), and higher() return elements respectively less than, less than or equal, greater than or equal, and greater than a given element,

*List<E>*An sequenced collection that allows duplicate elements.

*Queue<E>*A collection designed for holding elements prior to processing - insertion, extraction, and inspection operations. These processing methods exists in two forms: one throws an exception if the operation fails, the other returns a special value (e.g. null or false).

*Deque<E>*Pronounced "deck", is a double ended Queue that supports element insertion and removal at both ends.

**Collections Class Implementation:**

Set:

**HashSet<E>**A Set implementation without guarantees as to the iteration order of the set.

*LinkedHashSet<E>*A Set implementation that maintains a doubly-linked list running through all of its entries, thus iterable.

**A NavigableSet implementation based on a TreeMap. The elements are ordered using their natural ordering, or by a Comparator provided at set creation time.**

*TreeSet<E>*List:

*ArrayList<E>*A resizable-array implementation of the List. Not synchronized thus not thread-safe.

*Vector<E>*A resizable-array implementation of the List. Synchronized thus thread-safe.

*Stack<E>*A Vector with extra 5 operations that allow a vector to be treated as a stack. The Stack class represents a last-in-first-out (LIFO) stack of objects.

*LinkedList<E>*A Doubly-linked list implementation of the List and Queue interfaces.

Queue:

*LinkedList<E>*A Doubly-linked list implementation of the List and Queue interfaces.

*PriorityQueue<E>*A Queue implementation based on a heap. You can put one in, and you can take out the current highest priority. Priorities can be any Comparable value. The elements of the priority queue are ordered according to their natural ordering, or by a Comparator provided at queue construction time. A priority queue does not permit null elements.

## Map<K,V>

**Map Interfaces:**

*Map<K,V>*Key-value pairs.

*SortedMap<K,V>*A Map that provides ordering on its keys or by a Comparator typically provided at sorted map creation time.

*NavigableMap<K,V>*A SortedMap with extra navigation methods reporting closest matches for given search targets. For example, methods lowerEntry(), floorEntry(), ceilingEntry(), and higherEntry() return Map.Entry objects associated with keys respectively less than, less than or equal, greater than or equal, and greater than a given key.

*ConcurrentMap<K,V>*A Map with 3 extra methods added to Map<K,V>.

**Map Class Implementations:**

*HashMap<K,V>*An unsynchronized Map implementation that permits null key or null value.

*LinkedHashMap<K,V>*A HashMap with predictable iteration order (insertion order or access order).

*HashTable<K,V>*A synchronized Map implementation that doesn't permit null key or null value, without predictable iteration order.

**Properties<K,V>**Represents a persistent set of properties. The Properties can be saved to a stream or loaded from a stream. Each key and its corresponding value in the property list is a string.

*TreeMap<K,V>*A NavigableMap implementation. The elements are ordered using their natural ordering of its key, or by a Comparator provided at set creation time.

*ConcurrentHashMap<K,V>*A thread-safe Map supporting full concurrency via internally divided 'segments' being synchronized upon for updates. ConcurrentHashMap permits multiple simultaneous readers and writers.

*WeakHashMap<K,V>*Similar to a a HashMap, however, if a WeakHashMap key becomes garbage, its entry will be removed silently even though not necessarily immediately.