# hash chaining application in java api 
    * LinkedHashMap
      - double-linked list
      - access order by move access node to last
      - default by insert order
    * Hashtable
      - chaining with single linked list
      - indexing
          - hashtable: int index = (hash & 0x7FFFFFFF) % tab.length;
          - hashmap:   int index = (hash ^ (hash>>>16)) % (tab.length-1);
    * HashMap
      - if binCount <6, untrieefy to list 
      - if binCount >8, (if table.length >64, trieefy to RBT; else resize())
      - if map.size > (threshold=capacity*loadfactor), resize()

```java

     /**
       * The maximum capacity, used if a higher value is implicitly specified
       * by either of the constructors with arguments.
       * MUST be a power of two <= 1<<30.
       */
      static final int MAXIMUM_CAPACITY = 1 << 30;

      /**
       * The load factor used when none specified in constructor.
       */
      static final float DEFAULT_LOAD_FACTOR = 0.75f;

      /**
       * The bin count threshold for using a tree rather than list for a
       * bin.  Bins are converted to trees when adding an element to a
       * bin with at least this many nodes. The value must be greater
       * than 2 and should be at least 8 to mesh with assumptions in
       * tree removal about conversion back to plain bins upon
       * shrinkage.
       */
      static final int TREEIFY_THRESHOLD = 8;

      /**
       * The bin count threshold for untreeifying a (split) bin during a
       * resize operation. Should be less than TREEIFY_THRESHOLD, and at
       * most 6 to mesh with shrinkage detection under removal.
       */
      static final int UNTREEIFY_THRESHOLD = 6;

      /**
       * The smallest table capacity for which bins may be treeified.
       * (Otherwise the table is resized if too many nodes in a bin.)
       * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
       * between resizing and treeification thresholds.
       */
      static final int MIN_TREEIFY_CAPACITY = 64;
      /**
       * The table, initialized on first use, and resized as
       * necessary. When allocated, length is always a power of two.
       * (We also tolerate length zero in some operations to allow
       * bootstrapping mechanics that are currently not needed.)
       * RBT Or LinkedList
       */
      transient Node<K,V>[] table;

      /**
       * The number of key-value mappings contained in this map.
       */
      transient int size;

      /**
       * The number of times this HashMap has been structurally modified
       * Structural modifications are those that change the number of mappings in
       * the HashMap or otherwise modify its internal structure (e.g.,
       * rehash).  This field is used to make iterators on Collection-views of
       * the HashMap fail-fast.  (See ConcurrentModificationException).
       */
      transient int modCount;

      /**
       * The next size value at which to resize (capacity * load factor).
       *
       * @serial
       */
      int threshold;

      /**
       * The load factor for the hash table.
       *
       * @serial
       */
      final float loadFactor;