public V put(K key, V value) {
//put元素的时候，先判断key是否为null【HashMap允许最多一个key为null，多个key的value为null的情况，HashTable不允许null】
        if (key == null)
//nullkey都插入到数组的第一个元素里
            return putForNullKey(value);
//获得hash值，然后计算数组下标
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
//获得这个下标的链表，遍历之，如果发现某一项的hash值与要添加的key的哈希值相同，并且这个项里面的key的值也许要存入的key的值相同(字面值)，那么做一个更新操作，把新的value放进去，返回旧的value
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
//假如是一个新的项，那么对所有的key-value对数量加1，并且将这个entry添加到这个链表当中。
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

//如果之前的判断没有走，说明这个下标里面还没有entry实例，还是空的。
void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
//赋值给一个新的entry，如果下面判断数组的size超过了负载因子规定的阈值，就扩容这个HashMap
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

//如果数组已经达到了最大值，那么HashMap里面的键值对最大设置为int类型的最大值，不知道是不是MAXMUM_CAPACITY*0.75
//下面是创建一个新的table，并重新设置。这里transfer是将旧的数组复制到新的数组中，需要重新计算hash值重新排列
void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }
//transfer里面的具体算法没怎么看懂，只知道是重新映射

void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
//这里一开始没有看懂，应该是把当前元素的下一个元素定义为第一个元素，这样的话，新来的元素就继续占据表头，下一个元素就是之前上一个元素。
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }
//第一次循环中，拿到第一个元素放到表头处，并定义第一个元素的下一个元素的地址就是表头。这样第二次循环的时候第二个元素就自然插到表头，第一个元素下移一位。
//这个可能涉及到链表的实现方式，这里还不是很清楚。

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        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.equals(k)))
                return e.value;
        }
        return null;
    }
//get方法先判断null，然后去桶里遍历所有项，只有hash，key都相同时，把值拿出来。如果桶里什么都没有，说明这个key没有数据，返回null。

private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

//HashTable
publicclassHashtable<K,V>
extendsDictionary<K,V>
implementsMap<K,V>,Cloneable, java.io.Serializable{
//HashMap
publicclassHashMap<K,V>
extendsAbstractMap<K,V>
implementsMap<K,V>,Cloneable,Serializable
{
//HashTable是基于旧的Dictionary类扩展的，HashMap是从Map直接过来的的。
//Dictionary类已经过时了，并不推荐直接扩展此类，实际上HashTable基本的实现和HashMap都差不多。