阅读HashMap源码

• 先看看常量

  //默认初始容量，必须是2的幂
  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
  //最大容量
  static final int MAXIMUM_CAPACITY = 1 << 30;
  //负载因子，0.75符合泊松分布
  static final float DEFAULT_LOAD_FACTOR = 0.75f;
  //树的阈值，链表长度达到8就转为红黑树
  static final int TREEIFY_THRESHOLD = 8;
  //链表阈值
  static final int UNTREEIFY_THRESHOLD = 6;
  //元素至少一共有这么多，才允许树化链表
  static final int MIN_TREEIFY_CAPACITY = 64;

• ```java
  /一个Node节点
  四个成员变量：哈希值，Key名，value值，next指针
  构造函数
  获取键
  获取值
  toString()
  获取hashcode，是键和值的按位与
  覆盖值
  比较值是否一致 /
  static class Node implements Map.Entry {

  final int hash;
  final K key;
  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;
  }
  

  }

  - ```java
    //当前负载因子
    final float loadFactor;
    /*两个参数的构造
    (大小,负载因子)
    */
    public HashMap(int initialCapacity, float loadFactor) {
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal initial capacity: " +
                                                   initialCapacity);
            if (initialCapacity > MAXIMUM_CAPACITY)
                initialCapacity = MAXIMUM_CAPACITY;
            if (loadFactor <= 0 || Float.isNaN(loadFactor))
                throw new IllegalArgumentException("Illegal load factor: " +
                                                   loadFactor);
            this.loadFactor = loadFactor;
            this.threshold = tableSizeFor(initialCapacity);
        }
    public HashMap(int initialCapacity) {
            this(initialCapacity, DEFAULT_LOAD_FACTOR);
        }
    public HashMap() {
            this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
        }

• /*
  如果HashMap不为空，且存在该key的节点
  总是先检查第一个是否匹配
  若是链表，遍历比较
  若是树，进入getTreeNode
  */
  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) {
          if (first.hash == hash && // always check first node
              ((k = first.key) == key || (key != null && key.equals(k))))
              return first;
          if ((e = first.next) != null) {
              if (first instanceof 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;
  }