Set<E> (interface):
    Collection of elements in Java where duplicate entries are ignored and 
    the ordering of elements is not controlled by a client.
    
    There are two common implementations:
        TreeSet<E> - O(lg n) operations and elements stored in sorted order
        HashSet<E> - O(1)    operations but no apparent ordering of elements

set operations:
    s.add(value)      -- adds a value to the set, doing nothing if the value
                         is already in the set
    s.remove(value)   -- remove the given value from the set
    s.contains(value) -- whether set contains the value
    s.size()          -- number of values in the set
    s.isEmpty()       -- true if empty, false otherwise

-----------------------------------------------------------

Iterator<E> (interface):
    A lightweight object that serves the same purpose for a data structure 
    that a Scanner does for a file or String.  Provides a convenient way to 
    iterate through the structure and remove elements at the same time.

    You ask the data structure for an iterator over it in this way:
        List<String> list = new ArrayList<>();
        ...
        Iterator<String> itr = list.iterator();

iterator operations: 
    itr.hasNext()  -- are there any values left? 
    itr.next()     -- returns the next value and moves itr forward
    itr.remove()   -- removes the value most recently returned by next

-----------------------------------------------------------

Map<K, V> (interface):
    Data structure which stores elements in (key, value) pairs.  The keys 
    and values can be of any type and they need not be the same type. You 
    typically use the keys to access the values, not the other way around.

    Also known as:
        dictionaries, associative arrays (arrays with indices of any type)

    There are two common implementations:
        TreeMap<K, V> - O(lg n) operations and keys stored in sorted order
        HashMap<K, V> - O(1)    operations but no apparent ordering of keys

map operations:
    m.put(key, value)   -- associates the given key with the given value,
                           overwriting the previous value if present
    m.get(key)          -- returns the value for the given key
    m.containsKey(key)  -- whether keySet contains the given key
    m.keySet()          -- returns a Set of the keys in the map
    m.size()            -- number of key-value pairs in the map