//这里只看这一小部分，其他重点的在下面详细解释 
   static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;    //就是我们说的map的key
        V value;    //value值，这两个都不陌生
        Entry<K,V> next;//指向下一个entry对象
        int hash;//通过key算过来的你hashcode值。

//1、哈希表基于map接口的实现，这个实现提供了map所有的操作，并且提供了key和value可以为null，(HashMap和HashTable大致上市一样的除了hashmap是异步的和允许key和value为null)，
这个类不确定map中元素的位置，特别要提的是，这个类也不确定元素的位置随着时间会不会保持不变。
Hash table based implementation of the Map interface. This implementation provides all of the optional map operations, and permits null values and the null key. 
(The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.) This class makes no guarantees as to the order of the map;
 in particular, it does not guarantee that the order will remain constant over time. 

//假设哈希函数将元素合适的分到了每个桶(其实就是指的数组中位置上的链表)中，则这个实现为基本的操作(get、put)提供了稳定的性能，迭代这个集合视图需要的时间跟hashMap实例(key-value映射的数量)的容量(在桶中)
成正比，因此，如果迭代的性能很重要的话，就不要将初始容量设置的太高或者loadfactor设置的太低，【这里的桶，相当于在数组中每个位置上放一个桶装元素】
This implementation provides constant-time performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets.
 Iteration over collection views requires time proportional to the "capacity" of the HashMap instance (the number of buckets) plus its size (the number of key-value mappings
). Thus, it‘s very important not to set the initial capacity too high (or the load factor too low) if iteration performance is important.

//HashMap的实例有两个参数影响性能，初始化容量(initialCapacity)和loadFactor加载因子，在哈希表中这个容量是桶的数量【也就是数组的长度】，一个初始化容量仅仅是在哈希表被创建时容量，在
容量自动增长之前加载因子是衡量哈希表被允许达到的多少的。当entry的数量在哈希表中超过了加载因子乘以当前的容量，那么哈希表被修改(内部的数据结构会被重新建立)所以哈希表有大约两倍的桶的数量
An instance of HashMap has two parameters that affect its performance: initial capacity and load factor. The capacity is the number of buckets in the hash table, 
and the initial capacity is simply the capacity at the time the hash table is created. The load factor is a measure of how full the hash table is allowed to get before
 its capacity is automatically increased. When the number of entries in the hash table exceeds the product of the load factor and the current capacity, the hash table 
is rehashed (that is, internal data structures are rebuilt) so that the hash table has approximately twice the number of buckets.

//通常来讲，默认的加载因子(0.75)能够在时间和空间上提供一个好的平衡，更高的值会减少空间上的开支但是会增加查询花费的时间（体现在HashMap类中get、put方法上），当设置初始化容量时，应该考虑到map中会存放
entry的数量和加载因子，以便最少次数的进行rehash操作，如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

As a general rule, the default load factor (.75) offers a good tradeoff between time and space costs. Higher values decrease the space overhead but increase the lookup
 cost (reflected in most of the operations of the HashMap class, including get and put). The expected number of entries in the map and its load factor should be taken 
into account when setting its initial capacity, so as to minimize the number of rehash operations. If the initial capacity is greater than the maximum number of
 entries divided by the load factor, no rehash operations will ever occur.

//如果很多映射关系要存储在 HashMap 实例中，则相对于按需执行自动的 rehash 操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。
If many mappings are to be stored in a HashMap instance, creating it with a sufficiently large capacity will allow the mappings to be stored more efficiently than letting 
it perform automatic rehashing as needed to grow the table

    static final Entry<?,?>[] EMPTY_TABLE = {};

    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
//看上面的注释就已经知道，DEFAULT_INITIAL_CAPACITY=16，DEFAULT_LOAD_FACTOR=0.75
//初始化容量：也就是初始化数组的大小
//加载因子：数组上的存放数据疏密程度。
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and the default load factor (0.75).
     *
     * @param  initialCapacity the initial capacity.
     * @throws IllegalArgumentException if the initial capacity is negative.
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * 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)//initialCapacity不能小于0
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)//initialCapacity大于最大容量时
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))//isNaN的作用是检测loadFactor是否是一个浮点数
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        this.loadFactor = loadFactor;    //初始化loadFactor
        threshold = initialCapacity;//将threshold变为16，其实这里赋值为16没什么用，只是单纯的记录一下这个16的值，好在后面讲此值给数组的长度。后面再初始化数组长度的时候，就会把该值给重新赋值
        init();//一个空的初始化方法
    }

//将参数Map转换为一个HashMap。
    public HashMap(Map<? extends K, ? extends V> m) {
//根据m中的size来设置初始化容量为多少合适，如果(m.size()/DEFAULT_LOAD_FACTOR)+1>DEFAULT_INITLAL_CAPACITY那么久取(m.size()/DEFAULT_LOAD_FACTOR)+1为初始化容量，反之取默认的，而加载因子就一直是默认的0.75
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
//增大table的容量的方法，table也就是链表散列的数组。threshold就是初始化的大小(m.size()/DEFAULT_LOAD_FACTOR)+1或者DEFAULT_INITLAL_CAPACITY16
        inflateTable(threshold);

        putAllForCreate(m);
    }

    /**
     * Inflates the table.
     */
//扩展table的功能
    private void inflateTable(int toSize) {
        // Find a power of 2 >= toSize
//返回一个大于等于 最接近toSize的2的幂数。 什么意思呢？2的3次方的幂数就是8.2的幂数就是每次都市2的几次方，2的幂数有可能是1，2，4，8，16等。
比如toSize=16，则16的2的幂数就是2的4次方还是16，比如toSize=17，那么最接近他的2的幂数就是2的5次方，也就是32.
//这里不点进去看了，因为里面就是为了实现上面这个目的而写的一些算法，有兴趣的可以自己去读一读
        int capacity = roundUpToPowerOf2(toSize);
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//设置一个需要扩增数组的一个标准 上面也有说到这个变量，不清楚的回头再看看
//将table数组大大小改变为capacity。
        table = new Entry[capacity];
//初始化一个容量为capacity的哈希表，等用到的时候才真正初始化，返回值是boolean，先放一放。。。。。。。。。。
        initHashSeedAsNeeded(capacity);
    }

//添加元素
    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {//判断是不是一个空的数组，也就是数组没有长度，通过构造方法创建，还没开始用，所以长度为0，这里就开始对数组进行增长。
            inflateTable(threshold);//这个方法在第四个构造方法中介绍过，就是用来将数组变为大于等于threshold的2次幂。一开始threshold为16，那么根据算法，数组的开始长度也就是为16.
        }
        if (key == null)//这里可以看到，HashMap为什么可以使用null值了。
            return putForNullKey(value);//将key为null的值存放到table中去。具体看下面putForNullKey的分析。
        int hash = hash(key);//通过hash函数来将key转换为一个hash值
        int i = indexFor(hash, table.length);//通过这个方法，将key转换来的hash值和数组的长度进行操作，得到在数组中的位置。
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {//在对应位置上加入新元素
            Object k;
　　　　　　　//遍历这个桶中的元素，看有没有相同的key值。　
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {//只有相同的hash值并且 (可能key相同但是Key的hashcode不同也算key一样或者用equals比较得到相同)这说明里面有相同的key值。
                V oldValue = e.value;//将老value用新value来替代。
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);//增加元素，方法内部实现很简单，就是将新增加的元素放第一位。而不是往后追加。
        return null;
    }

//key为null的元素，默认放在table数组中的第一个位置上。并且可以知道，如果第一个位置上有元素，则将原来的值覆盖掉，如果第一个位置上没有entry。那么就将自己放在第一个位置。
   private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {//遍历在数组第一个位置上的链表的每个元素(entry)，其实就一个，因为null就一个。
            if (e.key == null) {//如果发现有key为null的值，将现在的值赋值给原来key为null的value。
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);//一个空的方法。
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);//上面的情况是有key为null的元素。现在这里是没有key为null的元素，则要在第一个位置上放上自己。请看下面对这个方法的解析。
        return null;
    }

    void addEntry(int hash, K key, V value, int bucketIndex) {
//增加元素前，看一下元素的个数是否大于等于了我们规定存放在数组中的个数(threshold=数组容量*加载因子，只是一个存放判定数组是否需要扩增标准的变量)，并且在table这个指定位置上有元素，则对数组进行扩展

//前面一个条件成立，扩展数组，可以理解，为什么还要加上后面一个条件呢？原因是：我们希望尽量在每个数组的每个位置上只有一个元素是最好的，数组的容量是大于threshold的，也就是说size虽然到了要扩增的那个标准，

但是在数组中可能还是有很多位置上没有放元素，所以在这些位置上增加元素是合理的，不需要扩增。只有等到在size达到了扩增的标准并且添加元素的位置上有别的元素的情况下，才进行阔增。
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);//扩增数组，看下面的分析。
            hash = (null != key) ? hash(key) : 0;//扩增完数组后，原来的那些参数就没用了。需要重新计算，计算添加元素的hash值
            bucketIndex = indexFor(hash, table.length);//通过hash值和数组的长度来计算出在数组中哪个位置
        }

        createEntry(hash, key, value, bucketIndex);//如果没有扩增，则直接用传过来的参数进行创建entry，很简单，将添加进入的元素放桶中的第一个元素，也就是数组对应位置就是该元素，然后把之后的元素给现在元素的next，具体可以看这个方法的源码，很简单
    }

   void resize(int newCapacity) {
        Entry[] oldTable = table;//将老的数组存放在oldTable中
        int oldCapacity = oldTable.length;//老的数组容量
        if (oldCapacity == MAXIMUM_CAPACITY) {//判断老的容量
            threshold = Integer.MAX_VALUE;//数组已经扩增到最大值了，所以将判定的标准增加到最大。
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//创建一个是原先两倍大小的数组。
        transfer(newTable, initHashSeedAsNeeded(newCapacity));//因为新数组的长度改变了，所以每个元素在新数组中的位置也会改变，所以需要将每个元素的key得到的hashcode值重新算一遍，放入新数组中
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//这里就可以知道threshold的真正作用了，就是上面说的，作为判定是否需要扩增数组的一个标准。
    }

    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {//遍历老数组中的每一个桶，其实就是遍历数组的每一个位置。
            while(null != e) {//遍历桶中的元素。e==null的情况是在一个桶中的最后一个元素的next为指向null，或者一开始这个桶就是空的。则需要遍历下一个桶。
                Entry<K,V> next = e.next;//将e元素的下一个元素保存到next中。
                if (rehash) {//
                    e.hash = null == e.key ? 0 : hash(e.key);//将每个元素的hash值算出来，通过的是每个元素的key，这个算法感兴趣的就点进去看。key和value为null的hash就为0，所以都在数组的第一个位置。
                }
                int i = indexFor(e.hash, newCapacity);//通过每个元素的hash值和所在数组的长度，计算出放在数组中哪个位置，这里就揭示了一开始我们的疑惑，不知道通过hash值怎么得到对应数组中的位置。
                e.next = newTable[i];//每次在桶中添加新的数据，都是把新数据放在开头，旧数据放后面，这个桶就相当于是一个栈，先进去的就在最底层。
                newTable[i] = e;//将自己放入数组中的对应位置
                e = next;//桶中下一个元素。
            }
        }
    }

    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);//通过与运算，将h的二进制，和length-1的二进制进行与运算得出的结果就是数组中的位置。
    }

//通过key删除entry并返回其value值，
    public V remove(Object key) {
//通过removeEntryForKey来完成删除功能
        Entry<K,V> e = removeEntryForKey(key);
//返回值。
        return (e == null ? null : e.value);
    }

   final Entry<K,V> removeEntryForKey(Object key) {
        if (size == 0) {//看hashMap中有没有值
            return null;
        }
        int hash = (key == null) ? 0 : hash(key);//看key是不是为null，如果为null，就直接返回0，否则通过hash函数计算出hash值
        int i = indexFor(hash, table.length);//得到在数组中的位置。
        Entry<K,V> prev = table[i];
        Entry<K,V> e = prev;

        while (e != null) {//开始遍历桶中所有的元素，看有没有该key值，这个下面，prev代表前一个元素、e代表当前要检测的元素，next代表e的后一个元素，除了第一次prev=e，其他时候都市像前面这样。
            Entry<K,V> next = e.next;//next记下一个元素
            Object k;　　　　
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {//判断是该key值，
                modCount++;
                size--;//要删除元素了，size自减
                if (prev == e)//只有在刚开始，自己处于第一个元素的时候，这个才会等于，其他情况prev代表的是删除元素的前一个元素，
                    table[i] = next;//如果是第一个元素，直接把桶中第一个元素指向next，在next中保存着原先的第二个元素，现在变为第一个元素了
                else　　　　　　　　//删除的就不是第一个元素，而是之后的，由于是单链表，就只需要改变一个指向引用，就是在要删除的元素之前的元素的next指向要删除的元素的next。
                    prev.next = next;//next：删除元素之后的一个元素，prev：删除元素的前一个元素，所以就有了这句话
                e.recordRemoval(this);//一个空方法
                return e;
            }
            prev = e;//记录要删除元素的前一个元素
            e = next;//这个就是可能要删除的元素。
        }

        return e;
    }

//通过key获得value，知道了hashMap的原理后，其实这些都市大同小异。
    public V get(Object key) {
        if (key == null)//判断是否为null
            return getForNullKey();//这个方法里太简单了，做两件事情，第一，如果size=0，返回null，反之到数组的第一个位置获取null对应的value值，前提是有，没有也返回null。
        Entry<K,V> entry = getEntry(key);//通过key获得entry对象，看一下里面是如何获得的，我猜跟那个通过key删除元素差不多。也还是先找到对应位置，然后遍历链表。

        return null == entry ? null : entry.getValue();//返回
    }

//和remove(key)这个方法的逻辑一样，但是简单得多，因为不用删除，只需要找到然后返回entry对象即可
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }