JDK源码阅读--HashMap

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

基于hash表的Map集合，允许key=null和value=null，HashMap是不同步的，不能保证Map集合的顺序，它是无序的Map集合.

HashMap有两个参数影响它的性能： 初始化容量（initial capacity） 和 负载因子（load factor）。
      初始化容量：就是创建 hash表时的容量
      负载因子：负载因子是衡量在哈希表的容量被自动增加之前，哈希表被允许获得多少满的度量。
                 当哈希表中的条目数超过负载因子和当前容量的乘积时，哈希表将被重新哈希(即重新构建内部数据结构)，
                     这样哈希表的桶数大约是桶数的两倍。

默认的负载因子是0.75f,这是一个在时间和空间上的一个折中；较高的值减少了空间开销，但增加了查找成本(主要表现在HaspMap的get和put操作)。
　　 如果初始容量大于最大条目数除以负载因子，则不会发生任何重哈希操作。

底层数据结构是链表数组，

 /**
      * 默认初始化容量是16
      */
     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

     /**
      * 最大的容量，如果较高的值由带参数的任何构造函数隐式指定，则使用。
      * 必须是2的幂，最大容量为1073741824
      */
     static final int MAXIMUM_CAPACITY = 1 << 30;//

     /**
      * 当构造函数中没有指定时使用的负载因子，默认是0.75f;
      */
     static final float DEFAULT_LOAD_FACTOR = 0.75f;

     // 一个桶的树化阈值
     // 当桶中元素个数超过这个值时，需要使用红黑树节点替换链表节点
     // 这个值必须为 8，要不然频繁转换效率也不高
     static final int TREEIFY_THRESHOLD = 8;

     // 一个树的链表还原阈值
     // 当扩容时，桶中元素个数小于这个值，就会把树形的桶元素 还原（切分）为链表结构
     // 这个值应该比上面那个小，至少为 6，避免频繁转换
     static final int UNTREEIFY_THRESHOLD = 6;

     // 哈希表的最小树形化容量
     // 当哈希表中的容量大于这个值时，表中的桶才能进行树形化
     // 否则桶内元素太多时会扩容，而不是树形化
     // 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
     static final int MIN_TREEIFY_CAPACITY = 64;

基本的hash表节点：

     /**
      * 基本的hash表节点，
      * （参见下面的forTreeNode子类，以及LinkedHashMap中的条目子类。）
      */
     static class Node<K,V> implements Map.Entry<K,V> {
         final int hash;//hash值 final修饰的
         final K key;//键  final修饰的
         V value;//值
         Node<K,V> next;//后置节点

         //构造函数
         Node(int hash, K key, V value, Node<K,V> next) {
             this.hash = hash;
             this.key = key;
             this.value = value;
             this.next = next;
         }

         public final K getKey()        { return key; }
         public final V getValue()      { return value; }
         public final String toString() { return key + "=" + value; }

         public final int hashCode() {
             return Objects.hashCode(key) ^ Objects.hashCode(value);
         }

         public final V setValue(V newValue) {
             V oldValue = value;
             value = newValue;
             return oldValue;
         }

         public final boolean equals(Object o) {
             if (o == this)
                 return true;
             if (o instanceof Map.Entry) {
                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                 if (Objects.equals(key, e.getKey()) &&
                     Objects.equals(value, e.getValue()))
                     return true;
             }
             return false;
         }
     }

 /**
      * 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.)
      * 第一次初始化的时候使用这个表。当分配时，长度总是2的幂
      */
     transient Node<K,V>[] table;

     /**
      * Holds cached entrySet(). Note that AbstractMap fields are used for keySet() and values().
      * 保存缓存entrySet()。注意AbstractMap字段用于keySet()和values()。
      */
     transient Set<Map.Entry<K,V>> entrySet;

     /**
      * The number of key-value mappings contained in this map.
      * 此映射中包含的键值映射的数目。
      */
     transient int size;

     /**
      * 被修改的次数
      */
     transient int modCount;

     /**
      * The next size value at which to resize (capacity * load factor).
      * 要调整大小的下一个大小值(容量*负载因子)。
      * @serial
      */
     int threshold;//要调整大小的下一个大小值(容量*负载因子)。

     /**
      * 哈希表的负载因子。
      * @serial
      */
     final float loadFactor;

构造函数：

 /**
      * 构造一个空的HashMap,使用专门的初始化容量和默认的负载因子。
      * @param  initialCapacity the initial capacity.
      * @throws IllegalArgumentException if the initial capacity is negative.
      */
     public HashMap(int initialCapacity) {
         this(initialCapacity, DEFAULT_LOAD_FACTOR);
     }

     /**
      * (16) and the default load factor (0.75).
      * 构造一个空的HashMap,使用默认的初始化容量(16)和默认的负载因子(0.75f)。
      */
     public HashMap() {
         this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
     }

     /**
      * 构造一个新的HashMap,使用与指定映射相同的映射。装载因子使用默认的(0.75f),和足够容纳指定Map中的映射的初始容量。
      * @param   m the map whose mappings are to be placed in this map 要在此映射中放置其映射的映射的映射
      * @throws  NullPointerException if the specified map is null 如果这个指定的map为null，则抛出空指针异常NullPointerException
      */
     public HashMap(Map<? extends K, ? extends V> m) {
         this.loadFactor = DEFAULT_LOAD_FACTOR;
         putMapEntries(m, false);
     }

  /**
      * 实现 Map.putAll和 Map的构造函数
      * @param m the map
      * @param evict  当最初构造这个map的时候为false，否则为true(传递到之后的插入节点的方法中)。
      */
     final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
         int s = m.size();
         if (s > 0) {
             if (table == null) { // pre-size
                 float ft = ((float)s / loadFactor) + 1.0F;
                 int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
                 if (t > threshold) {
                     threshold = tableSizeFor(t);
                 }
             }else if (s > threshold) {
                 resize();
             }
             for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                 K key = e.getKey();
                 V value = e.getValue();
                 putVal(hash(key), key, value, false, evict);
             }
         }
     }

 /**
      * @return 返回此映射中键值映射的数目。
      */
     public int size() {
         return size;
     }

     /**
      *  判断该map是否为空
      * @return  当此map中不含键值对的时候，返回true.
      */
     public boolean isEmpty() {
         return size == 0;
     }

get方法（先比较hash，若相等在比较equals）：

1. Key==null的时候，判断map也为空，就返回null
2. 根据node数组下标找到node数组下标
3. 如果当前node链表只存在一个数据就直接取value值
如果当前node链表存在多个node元素，则循环遍历node链表，分别对他们的hash值和key值，value值进行判断，知道找到node以后返回Value值，如果没有找到返回null。

  /**
      * 根据键key获取值value，如果此map不包含这个key，则返回null。
      * Returns the value to which the specified key is mapped,
      * or {@code null} if this map contains no mapping for the key.
      *
      * <p>More formally, if this map contains a mapping from a key
      * {@code k} to a value {@code v} such that {@code (key==null ? k==null :
      * key.equals(k))}, then this method returns {@code v}; otherwise
      * it returns {@code null}.  (There can be at most one such mapping.)
      *
      * <p>A return value of {@code null} does not <i>necessarily</i>
      * indicate that the map contains no mapping for the key; it's also
      * possible that the map explicitly maps the key to {@code null}.
      * The {@link #containsKey containsKey} operation may be used to
      * distinguish these two cases.
      *
      * @see #put(Object, Object)
      */
     public V get(Object key) {
         Node<K,V> e;
         return (e = getNode(hash(key), key)) == null ? null : e.value;
     }

     /**
      * Implements Map.get and related methods
      * Map.get相关方法的实现
      * @param hash hash for key  键key的hash值
      * @param key the key        键key
      * @return the node, or null if none  返回根据key及key的hash找到的这个节点；如果这个节点为空，则返回null
      *
      *
      */
     final Node<K,V> getNode(int hash, Object key) {
         Node<K,V>[] tab;
         Node<K,V> first, e;
         int n;
         K k;
         if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
             // always check first node 总是会检查哈希表的第一个节点
             if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k)))) {
                 return first;
             }
             if ((e = first.next) != null) {//如果第一个节点的下一个节点不为空
                 if (first instanceof TreeNode) {//如果该节点是TreeNode类型的(红黑树)
                     return ((TreeNode<K, V>) first).getTreeNode(hash, key);//调用红黑树的查找方法
                 }
                 do {
                     if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                         return e;
                     }
                 } while ((e = e.next) != null);
             }
         }
         return null;
     }

put方法：

1. 首先判断node数组，也就是数组是否为空，为空的话就初始化hashmap
2. 如果node数组不为空的话，就判断key是否为空，为空的话就将放到数组的第一个位置
3. 就通过key获取hash值，通过hash值做比较，如果key的hash值相等 并且key.equals(e.key)也相等的话,就将新的value替换掉旧的。如果条件不满足就创建一个node，且用上一个node的next指向新创建的node 。

 /**
      * 往map中添加新的键值对，如果键key存在，则将该键key对应的旧值value替换为新值value
      *
      * @param key 要与指定值关联的键
      * @param value 值与指定的键关联
      * @return 与key关联的前一个值，如果没有key的映射，则为null。(null返回值还可以指示以前将null与key关联的映射。)
      */
     public V put(K key, V value) {
         return putVal(hash(key), key, value, false, true);
     }

     /**
      * Implements Map.put and related methods
      * 实现Map.put和相关方法
      * @param hash hash for key    key的hash值
      * @param key the key           键
      * @param value the value to put  值
      * @param onlyIfAbsent   如果是true，不能改变已存在的值
      * @param evict  如果为false，该表处于创建模式
      * @return  返回前一个值，如果没有，则为空
      * 根据key算hash，根据容量和hash算index，table[index]没有直接添加到数组中，table[index]有，若index位置同一个key则更新，
      *      否则遍历next是否有，有则更新，无则新增，最后根据thread与size判断是否扩容。注：扩容时容量翻倍，重新算hash复制到新数组
      *
      */
     final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                    boolean evict) {
         Node<K,V>[] tab;
         Node<K,V> p;
         int n, i;
         if ((tab = table) == null || (n = tab.length) == 0) {
             n = (tab = resize()).length;
         }
         if ((p = tab[i = (n - 1) & hash]) == null) {
             tab[i] = newNode(hash, key, value, null);
         }else {
             Node<K,V> e; K k;
             if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
                 e = p;
             }else if (p instanceof TreeNode) {
                 e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
             }
             else {
                 for (int binCount = 0; ; ++binCount) {
                     if ((e = p.next) == null) {
                         p.next = newNode(hash, key, value, null);
                         if (binCount >= TREEIFY_THRESHOLD - 1) { // -1 for 1st
                             treeifyBin(tab, hash);
                         }
                         break;
                     }
                     if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
                         break;
                     }
                     p = e;
                 }
             }
             if (e != null) { // existing mapping for key
                 V oldValue = e.value;
                 if (!onlyIfAbsent || oldValue == null) {
                     e.value = value;
                 }
                 afterNodeAccess(e);
                 return oldValue;
             }
         }
         ++modCount;
         if (++size > threshold) {
             resize();
         }
         afterNodeInsertion(evict);
         return null;
     }