HashMap
基于哈希表的 Map 接口的实现。
此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）
此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
(from JDK DOC)

缺省的 Map大小是 16. (这里要求必须是 2 的幂数，为什么一定是 2的幂数(16,32,64,128...下边有解释).
 static final int DEFAULT_INITIAL_CAPACITY = 16;

缺省的比例因子是 0.75
 static final float DEFAULT_LOAD_FACTOR = 0.75f;

长度必须总是 2 的 幂数。
 保存 K,V 对象的数组
 transient Entry[] table;

/**
      * The next size value at which to resize (capacity * load factor).
      * @serial
      */
 重设 Entry[] table 的阀值( = capacity * load factor) 
 int threshold;

当前比例因子
 final float loadFactor;

记录修改次数  
 transient volatile int modCount;

/**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and load factor.
     *
     * @param  initialCapacity The initial capacity.
     * @param  loadFactor      The load factor.
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive.
     */
    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);

// Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;
   
        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor); loadFactor 默认是 0.75. 所以 threshold 默认是 12
        table = new Entry[capacity]; 按照给定的大小初化 Entry 数组。（默认情况下是  16 ）
        init();
    }
 
  
 
    看了下边这几行代码就能看出来 HashMap是怎么支持 null 做为 Key了。
    static final Object NULL_KEY = new Object();
    static <T> T maskNull(T key) {
        return key == null ? (T)NULL_KEY : key;
    }
    static <T> T unmaskNull(T key) {
        return (key == NULL_KEY ? null : key);
    }

HashMap 对key 值的  hash 算法。
    Object 类使用的 对象的 内部地址 提供 hashCode.
    String 使用一个算法提供hashCode。(算法:s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1])
    当然这样一种算法是不能完全保证 得到的hashCode是唯一的。
   
    String s1 = "结算";
    String s2 = "罚款";
    两个对象的hashcode是相同的(1038116);
    经过hash之后是-423929781.
   
    这个函数的算法我就看不大懂了。还有高人指教了。
 
    static int hash(Object x) {
        int h = x.hashCode();
        h += ~(h << 9);
        h ^=  (h >>> 14);
        h +=  (h << 4);
        h ^=  (h >>> 10);
        return h;
    }
   
    根据hashCode值 值和 当前 Entry数组的长度计算 该数据应该在数组中的索引值
    因为这里的算法 所以 capacity 大小必须为 2 的幂数。
    举例，默认值是 16 ， 其减1是 15, 二进制是 00001111 .
    h 是一个特殊的 hash值。 与  0x0F进行 & 操作当然结果应该在 0x0F以内了。
    但这里必须保证 length -1 全为 1. 否则话某些位可能永远是 0,那么Entry数组
    的一个范围可能永远也不会被用到。
   
    这里没使用取余计算应该出于效率考虑的吧。
    static int indexFor(int h, int length) {
        return h & (length-1);
    }
   
   
    public V get(Object key) {
        Object k = maskNull(key);    //检查是否是null Key
        int hash = hash(k);          //计算hash
        int i = indexFor(hash, table.length); //计算索引
        Entry<K,V> e = table[i];              //取得Entry对象
        while (true) {                        //循环查找链上 对象
            if (e == null)