HashMap 源码解析-前序

     //创建 HashMap 时未指定初始容量情况下的默认容量  
     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
 
 　  //HashMap 的最大容量
     static final int MAXIMUM_CAPACITY = 1 << 30;
 
     //HashMap 默认的装载因子,当 HashMap 中元素数量超过 容量*装载因子 时，进行　resize()　操作
     static final float DEFAULT_LOAD_FACTOR = 0.75f;
 
     //用来确定何时将解决 hash 冲突的链表转变为红黑树
     static final int TREEIFY_THRESHOLD = 8;
 
     // 用来确定何时将解决 hash 冲突的红黑树转变为链表
     static final int UNTREEIFY_THRESHOLD = 6;
  
     //当需要将解决 hash 冲突的链表转变为红黑树时，需要判断下此时数组容量，若是由于数组容量太小（小于　MIN_TREEIFY_CAPACITY　）导致的 hash 冲突太多，
     //则不进行链表转变为红黑树操作，转为利用　resize() 函数对　hashMap 扩容　
     static final int MIN_TREEIFY_CAPACITY = 64;

     //保存Node<K,V>节点的数组
     transient Node<K,V>[] table;
    
     //由　hashMap 中 Node<K,V>　节点构成的 set
     transient Set<Map.Entry<K,V>> entrySet;
    
     //记录 hashMap 当前存储的元素的数量
     transient int size;
    
     //记录　hashMap 发生结构性变化的次数（注意　value 的覆盖不属于结构性变化）
     transient int modCount;
    
     //threshold的值应等于 table.length * loadFactor, size 超过这个值时进行　resize()扩容
     int threshold;
    
     //记录 hashMap 装载因子
     final float loadFactor;

// Node<K,V> 类用来实现数组及链表的数据结构
 　 static class Node<K,V> implements Map.Entry<K,V> {
         final int hash; //保存节点的 hash　值
         final K key; //保存节点的　key　值
         V value;　//保存节点的　value 值
         Node<K,V> next;　//指向链表结构下的当前节点的　next 节点，红黑树　TreeNode　节点中也有用到
 
         Node(int hash, K key, V value, Node<K,V> next) {
             this.hash = hash;
             this.key = key;
             this.value = value;
             this.next = next;
         }
     }
     
 　  // TreeNode<K,V> 继承 LinkedHashMap.Entry<K,V>，用来实现红黑树相关的存储结构
     static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
         TreeNode<K,V> parent;  // 存储当前节点的父节点
         TreeNode<K,V> left;　//存储当前节点的左孩子
         TreeNode<K,V> right;　//存储当前节点的右孩子
         TreeNode<K,V> prev;    // 存储当前节点的前一个节点
         boolean red;　// 存储当前节点的颜色（红、黑）
         TreeNode(int hash, K key, V val, Node<K,V> next) {
             super(hash, key, val, next);
         }
      }    

//构造方法１，指定初始容量及装载因子
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;
    　  /**   tableSizeFor(initialCapacity)　方法返回的值是最接近 initialCapacity 的2的幂，
         *    若指定初始容量为９，则实际 hashMap 容量为16
         */
        this.threshold = tableSizeFor(initialCapacity);
}

//构造方法２，仅指定初始容量，装载因子的值采用默认的　0.75
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//构造方法３，所有参数均采用默认值
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

//tableSizeFor(initialCapacity)　方法返回的值是最接近 initialCapacity 的2的幂
static final int tableSizeFor(int cap) {
        int n = cap - 1;
        /**
         *    以下表达式为 n的二进制与 n的二进制数右移后x位的结果进行异或
         *    目的是保证高位1后的数据均为1,普及一下如果高位1后面全是1的话，
         *    即 0000 0000 0000 0000 0000 0000 0000 1111 
         *    这样的二进制表示为 15，可以推导出 为2的幂-1。
         *    至于为何 右移 1 + 2 + 4 + 8 + 16 = 31位
         *    是因为一个 Integer 类型占 4 字节，一个字节占 8 位二进制码，
         *    因此一个 Integer 总共占 32 位二进制码。去除第一位的符号位，
         *    剩下 31 位来表示数值。所以右移31位，以此保证高位1后面的数据均为1。    
         */
        
        
        
        
        n |= n >>> 1;// >>> 代表无符号右移
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        /**
         *    当n小于 最大值时
         *    返回 n+1，由上面我们知道 如果高位1后面全是1的话，
         *    用十进制表示为 2的n次方-1,所以返回的n+1 则为
         *    2的n次方，这就是为什么hashmap的容量必须会是2的n次方
         */
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}