Java Notes-10

Summay: The Map Interface, Collection implementations

-Maps store and retrieve elements with key values

e.g:

Map<String, Date> dateMap = new HashMap<String, Date>();
dateMap.put( "today", new Date() );
Date today = dateMap.get( "today" );

-Functions:

public V put( K key , V value )//This method adds the specified key/value pair to the map. 
public V get( K key )//This method retrieves the value corresponding to  key from the map.
public V remove( K key )//This method removes the value corresponding to  key from the map
public int size()//Use this method to find the number of key/value pairs in this map
public Set keySet()//This method returns a  Set that contains all the keys in this map.
public Collection values()//Use this method to retrieve all the values in this map

-Map has one child interface,  SortedMap . A  SortedMap maintains its key/value pairs sorted
in a particular order according to the key values. 

-All of the methods of the  Collection interface would appear to make sense for  Map ,
except for  iterator() . A  Map , again, has two sets of objects: keys and values, and separate
iterators for each. This is why a  Map does not implement  Collection 

-ConcurrentMap, It extends the base  Map interface and adds atomic put, remove, and replace functionality that is
useful for concurrent programming

public V putIfAbsent( K key, V value )//This method associates the value with the key only if the key was not already in use.
public boolean remove( Object key, Object value )//This method removes the mapping (key and value) only if the current value asso‐
ciated with the key equals the supplied value
public boolean replace( K key, V existingValue, V newValue)//This method replaces the value associated with the key only if the existing value
equals the  existingValue argument.
public boolean replace( K key, V value )//This method replaces the value associated with the key only if a mapping already
exists for the key

-Arrays are described as consuming constant time for retrieval, but linear time for insertion into or deletion from the body of the array. 

-Arrays are useful when you are mostly reading or exclusively appending to the end of the collection.

-Link List  holds its elements in a chain of nodes, each referencing the node before and after it (if any).

-Unlike the magic of an array, however, to retrieve an element from a linked list, you must traverse the list from either the head or
tail to reach the correct spot. As you might have guessed, this is a linear-time operation that gets more expensive as the number of elements grows. 

-Linked lists are useful when you are doing a lot of insertions or deletions on a collection

-Trees are useful for maintaining and searching large collections of sorted elements.

-A hash map (or hash table, as it is also called) uses a mathematical hash algorithm applied to its key value to distribute its element

-Java Collections implementations

Collections Framework implementation classes

Interface	Implementation
Set	HashSet LinkedHashSet CopyOnWriteArraySet EnumSet CopyOnWriteArraySet
SortedSet	TreeSet ConcurrentSkipListSet
List	ArrayList LinkedList Vector a Stack CopyOnWriteArrayList
Map	HashMap EnumMap LinkedHashMap IdentityHashMap Hashtable a
ConcurrentMap	ConcurrentHashMap ConcurrentSkipListMap
SortedMap	TreeMap
Queue / Dequeue	LinkedList ArrayDeque PriorityQueue DelayQueue SynchronousQueue ConcurrentLinkedQueue ConcurrentLinkedDequeue
BlockingQueue	ArrayBlockingQueue LinkedBlockingQueue PriorityBlockingQueue

Next Synchronized and Unsynchronized Collections...