java中HashMap的实现

public interface Map {

    int size();//大小

    boolean isEmpty();//是否为空

    boolean containsKey(Object key);//是否包含指定的key

    boolean containsValue(Object value);//是否包含指定的value

    V get(Object key);//通过key获取value

    V put(K key, V value);//新增一个键值对

    V remove(Object key);//通过key移除元素

    void putAll(Map m);//将m中的元素加入到map中

    void clear();//清空

    Set keySet();//保存了key的set

    Collection values();//保存了value的collection

    Set> entrySet();//保存了Entry的set

    interface Entry {//map存储的元素
	K getKey();//获取key

	V getValue();//获取value

	V setValue(V value);//设置value

	boolean equals(Object o);//比较

	int hashCode();//哈希code
    }

    boolean equals(Object o);//比较

    int hashCode();//哈希code
}

public abstract class AbstractMap implements Map {

    protected AbstractMap() {
    }

    public int size() {
	return entrySet().size();//返回大小
    }

    public boolean isEmpty() {
	return size() == 0;//大小是否等于0
    }

    public boolean containsValue(Object value) {
    //从map中查找是否包含value
	Iterator> i = entrySet().iterator();
	if (value==null) {
	    while (i.hasNext()) {
		Entry e = i.next();
		if (e.getValue()==null)
		    return true;
	    }
	} else {
	    while (i.hasNext()) {
		Entry e = i.next();
		if (value.equals(e.getValue()))
		    return true;
	    }
	}
	return false;
    }

    public boolean containsKey(Object key) {
    //从map中查找是否包含key
	Iterator> i = entrySet().iterator();
	if (key==null) {
	    while (i.hasNext()) {
		Entry e = i.next();
		if (e.getKey()==null)
		    return true;
	    }
	} else {
	    while (i.hasNext()) {
		Entry e = i.next();
		if (key.equals(e.getKey()))
		    return true;
	    }
	}
	return false;
    }

    public V get(Object key) {
    //从map中查找key对应的value
	Iterator> i = entrySet().iterator();
	if (key==null) {
	    while (i.hasNext()) {
		Entry e = i.next();
		if (e.getKey()==null)
		    return e.getValue();
	    }
	} else {
	    while (i.hasNext()) {
		Entry e = i.next();
		if (key.equals(e.getKey()))
		    return e.getValue();
	    }
	}
	return null;
    }

    public V put(K key, V value) {
	//子类实现
	throw new UnsupportedOperationException();
    }

    public V remove(Object key) {
	//先遍历找到要删除的entry
	Iterator> i = entrySet().iterator();
	Entry correctEntry = null;
	if (key==null) {
	    while (correctEntry==null && i.hasNext()) {
		Entry e = i.next();
		if (e.getKey()==null)
		    correctEntry = e;
	    }
	} else {
	    while (correctEntry==null && i.hasNext()) {
		Entry e = i.next();
		if (key.equals(e.getKey()))
		    correctEntry = e;
	    }
	}

	V oldValue = null;
	if (correctEntry !=null) {
	    oldValue = correctEntry.getValue();//保存旧数据
	    i.remove();//删除
	}
	return oldValue;
    }

    public void putAll(Map m) {
        for (Map.Entry e : m.entrySet())//迭代entry，然后put到map中
            put(e.getKey(), e.getValue());
    }

    public void clear() {//清除
	entrySet().clear();
    }

    transient volatile Set        keySet = null;//存储key的set
    transient volatile Collection values = null;//存储value的collection

    public Set keySet() {
	//通过继承AbstractSet，并用set的迭代器封装迭代操作（key是唯一的，所以会用到set？？？）
	if (keySet == null) {
	    keySet = new AbstractSet() {
		public Iterator iterator() {
		    return new Iterator() {
			private Iterator> i = entrySet().iterator();

			public boolean hasNext() {
			    return i.hasNext();
			}

			public K next() {
			    return i.next().getKey();
			}

			public void remove() {
			    i.remove();
			}
                    };
		}

		public int size() {
		    return AbstractMap.this.size();
		}

		public boolean contains(Object k) {
		    return AbstractMap.this.containsKey(k);
		}
	    };
	}
	return keySet;
    }

    public Collection values() {
    //通过继承AbstractCollection，并用set的迭代器封装迭代操作
	if (values == null) {
	    values = new AbstractCollection() {
		public Iterator iterator() {
		    return new Iterator() {
			private Iterator> i = entrySet().iterator();

			public boolean hasNext() {
			    return i.hasNext();
			}

			public V next() {
			    return i.next().getValue();
			}

			public void remove() {
			    i.remove();
			}
                    };
                }

		public int size() {
		    return AbstractMap.this.size();
		}

		public boolean contains(Object v) {
		    return AbstractMap.this.containsValue(v);
		}
	    };
	}
	return values;
    }

    public abstract Set> entrySet();

    public boolean equals(Object o) {
	if (o == this)//内存地址相等，返回true
	    return true;

	if (!(o instanceof Map))//不是Map的对象，返回false
	    return false;
	Map m = (Map) o;
	if (m.size() != size())//大小不等，返回false
	    return false;

        try {//对map的元素进行比较
            Iterator> i = entrySet().iterator();
            while (i.hasNext()) {
                Entry e = i.next();
		K key = e.getKey();
                V value = e.getValue();
                if (value == null) {
                    if (!(m.get(key)==null && m.containsKey(key)))
                        return false;
                } else {
                    if (!value.equals(m.get(key)))
                        return false;
                }
            }
        } catch (ClassCastException unused) {
            return false;
        } catch (NullPointerException unused) {
            return false;
        }

	return true;
    }

    public int hashCode() {
	int h = 0;
	Iterator> i = entrySet().iterator();
	while (i.hasNext())
	    h += i.next().hashCode();
	return h;
    }

    public String toString() {
	Iterator> i = entrySet().iterator();
	if (! i.hasNext())
	    return "{}";

	StringBuilder sb = new StringBuilder();
	sb.append('{');
	for (;;) {
	    Entry e = i.next();
	    K key = e.getKey();
	    V value = e.getValue();
	    sb.append(key   == this ? "(this Map)" : key);
	    sb.append('=');
	    sb.append(value == this ? "(this Map)" : value);
	    if (! i.hasNext())
		return sb.append('}').toString();
	    sb.append(", ");
	}
    }

    protected Object clone() throws CloneNotSupportedException {
        AbstractMap result = (AbstractMap)super.clone();
        result.keySet = null;
        result.values = null;
        return result;
    }

    private static boolean eq(Object o1, Object o2) {
        return o1 == null ? o2 == null : o1.equals(o2);
    }

    public static class SimpleEntry
	implements Entry, java.io.Serializable
    {
	private static final long serialVersionUID = -8499721149061103585L;

	private final K key;
	private V value;

	public SimpleEntry(K key, V value) {
	    this.key   = key;
            this.value = value;
	}

	public SimpleEntry(Entry entry) {
	    this.key   = entry.getKey();
            this.value = entry.getValue();
	}

	public K getKey() {
	    return key;
	}

	public V getValue() {
	    return value;
	}

	public V setValue(V value) {
	    V oldValue = this.value;
	    this.value = value;
	    return oldValue;
	}

	public boolean equals(Object o) {
	    if (!(o instanceof Map.Entry))
		return false;
	    Map.Entry e = (Map.Entry)o;
	    return eq(key, e.getKey()) && eq(value, e.getValue());
	}

	public int hashCode() {
	    return (key   == null ? 0 :   key.hashCode()) ^
		   (value == null ? 0 : value.hashCode());
	}

	public String toString() {
	    return key + "=" + value;
	}

    }

    public static class SimpleImmutableEntry
	implements Entry, java.io.Serializable
    {
	private static final long serialVersionUID = 7138329143949025153L;

	private final K key;
	private final V value;

	public SimpleImmutableEntry(K key, V value) {
	    this.key   = key;
            this.value = value;
	}

	public SimpleImmutableEntry(Entry entry) {
	    this.key   = entry.getKey();
            this.value = entry.getValue();
	}

	public K getKey() {
	    return key;
	}

	public V getValue() {
	    return value;
	}

	public V setValue(V value) {
            throw new UnsupportedOperationException();
        }

	public boolean equals(Object o) {
	    if (!(o instanceof Map.Entry))
		return false;
	    Map.Entry e = (Map.Entry)o;
	    return eq(key, e.getKey()) && eq(value, e.getValue());
	}

	public int hashCode() {
	    return (key   == null ? 0 :   key.hashCode()) ^
		   (value == null ? 0 : value.hashCode());
	}

	//重写toString，打印出map的key=value
	public String toString() {
	    return key + "=" + value;
	}

    }

}


public class HashMap
    extends AbstractMap
    implements Map, Cloneable, Serializable
{

    static final int DEFAULT_INITIAL_CAPACITY = 16;//默认的桶的大小

    static final int MAXIMUM_CAPACITY = 1 << 30;//最大的桶的大小

    static final float DEFAULT_LOAD_FACTOR = 0.75f;//载入因子

    transient Entry[] table;//存放hashmap元素的数组

    transient int size;//table的大小

    int threshold;//重置桶数量的大小时使用（capacity * load factor）

    final float loadFactor;//载入因子

    transient volatile int modCount;//版本号

    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)//以2的倍数初始化数组大小
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }

    public HashMap(int initialCapacity) {//使用默认的载入因子初始化
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    public HashMap() {//使用默认的大小和载入因子初始化
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

    public HashMap(Map m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);//初始化
        putAllForCreate(m);//将m的元素仿佛新建的HashMap
    }

    void init() {//初始化，空实现
    }

    static int hash(int h) {哈希算法
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {//返回哈希code在桶中的索引
        return h & (length-1);
    }

    public int size() {//返回map的大小
        return size;
    }

    public boolean isEmpty() {//返回map是否是为空
        return size == 0;
    }

    public V get(Object key) {
        if (key == null)//如果key为空，则进入获取空key中的value的方法，不需要计算hashcode，java中null的hashcode为0
            return getForNullKey();
        int hash = hash(key.hashCode());//该key的hashcode
        for (Entry e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {//迭代该key所在的桶的元素，其中，Entry类中保存了获取在相同桶中的下一个元素，next
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))//进行equals和地址比较（如果该key对象没有重写equals则肯定是比较内存地址，否则调用重写后的equals比较）
                return e.value;
        }
        return null;
    }

    private V getForNullKey() {
        for (Entry e = table[0]; e != null; e = e.next) {//可以看到，key为null的元素时放在table数组中的一个位置
            if (e.key == null)//判断key是否null
                return e.value;
        }
        return null;
    }

    public boolean containsKey(Object key) {
        return getEntry(key) != null;//通过getEntry的方式判断是否存在该key
    }

    final Entry getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());//获取key的hashcode
        for (Entry e = table[indexFor(hash, table.length)];迭代该key所在的桶的元素
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))//进行equals和地址比较
                return e;
        }
        return null;
    }

    public V put(K key, V value) {
        if (key == null)//如果key为空，则进入put key为null的方法
            return putForNullKey(value);
        int hash = hash(key.hashCode());//计算hashcode
        int i = indexFor(hash, table.length);//获取hashcode在桶中的索引
        for (Entry e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {//如果在map中存在该key
                V oldValue = e.value;//获取旧value
                e.value = value;//设置新value，覆盖旧value
                e.recordAccess(this);//空实现???
                return oldValue;//返回旧数据
            }
        }

        modCount++;//版本号加1
        addEntry(hash, key, value, i);//在该桶中加入新的Entry，并与之前Entry通过next串联起来
        return null;
    }

    private V putForNullKey(V value) {
        for (Entry e = table[0]; e != null; e = e.next) {
            if (e.key == null) {//判断key是否为null
                V oldValue = e.value;//获取旧value
                e.value = value;//设置新value，覆盖旧value
                e.recordAccess(this);//空实现???
                return oldValue;//返回旧数据
            }
        }
        modCount++;//版本号加1
        addEntry(0, null, value, 0);//在该桶中加入新的Entry，并与之前Entry通过next串联起来
        return null;
    }

    private void putForCreate(K key, V value) {//注意：该方法不会使版本号发生变化
        int hash = (key == null) ? 0 : hash(key.hashCode());//计算hashcode
        int i = indexFor(hash, table.length);//获取hashcode在桶中的索引

        for (Entry e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {//如果在map中存在该key
                e.value = value;//设置新value，覆盖旧value
                return;//不返回旧value
            }
        }

        createEntry(hash, key, value, i);//在合适位置创建新的Entry
    }

    private void putAllForCreate(Map m) {
    //把m中元素copy到新的map中
        for (Iterator> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry e = i.next();
            putForCreate(e.getKey(), e.getValue());
        }
    }

    void resize(int newCapacity) {
        Entry[] oldTable = table;//保存旧table
        int oldCapacity = oldTable.length;//保存旧table的数组长度
        if (oldCapacity == MAXIMUM_CAPACITY) {//判断是否等于最大存储容量
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//根据指定的容量大小创建新的table
        transfer(newTable);//将数据copy给新table，重新调整元素在hash表中位置
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

    void transfer(Entry[] newTable) {
        Entry[] src = table;//旧table
        int newCapacity = newTable.length;//新table的长度
        for (int j = 0; j < src.length; j++) {// 遍历src里面的所有桶
            Entry e = src[j];//获取桶中Entry链表
            if (e != null) {
                src[j] = null;//将旧table中的桶置空，触发垃圾回收进行内存回收
                do {
                    Entry next = e.next;
                    int i = indexFor(e.hash, newCapacity);//计算存放位置
                    e.next = newTable[i];//设置链表连接
                    newTable[i] = e;//将元素保存到newTable中
                    e = next;//下一元素
                } while (e != null);
            }
        }
    }

     // 将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系
    public void putAll(Map m) {
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)//是否需要putall
            return;

        if (numKeysToBeAdded > threshold) {// 如果要复制的映射关系比阈值还要多，将map扩充
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);//计算扩充大小
            if (targetCapacity > MAXIMUM_CAPACITY)//扩充大小不能超出系统指定的大小
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)//如果现在的数组大小小于需要扩充的大小，扩展数组数量
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);//扩充
        }
	// 迭代将key-value映射放进该HashMap  
        for (Iterator> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry e = i.next();
            put(e.getKey(), e.getValue());
        }
    }

    public V remove(Object key) {
        Entry e = removeEntryForKey(key);//删除指定的key
        return (e == null ? null : e.value);//如果被删除的key存在该map，则返回value
    }

    final Entry removeEntryForKey(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());//计算hashcode
        int i = indexFor(hash, table.length);//计算索引
        Entry prev = table[i];
        Entry e = prev;

        while (e != null) {
            Entry next = e.next;
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {//找到key映射的value
                modCount++;//版本号加1
                size--;//大小减1
                if (prev == e)//如果第一个元素就是要删除元素
                    table[i] = next;//将下一个元素放置在table的i位置上，也就是重置链表的头部
                else
                    prev.next = next;//将被删除的元素的下一个元素赋给被删除的元素的前一个元素，使链表保持连续
                e.recordRemoval(this);
                return e;
            }
	    //移动链表
            prev = e;
            e = next;
        }

        return e;
    }


    final Entry removeMapping(Object o) {
        if (!(o instanceof Map.Entry))//如果不Entry元素，返回
            return null;

        Map.Entry entry = (Map.Entry) o;
        Object key = entry.getKey();
        int hash = (key == null) ? 0 : hash(key.hashCode());
        int i = indexFor(hash, table.length);
        Entry prev = table[i];
        Entry e = prev;

        while (e != null) {
            Entry next = e.next;
            if (e.hash == hash && e.equals(entry)) {//找到key映射的entry
                modCount++;//版本号加1
                size--;//大小减1
                if (prev == e)//如果第一个元素就是要删除元素
                    table[i] = next;//将下一个元素放置在table的i位置上，也就是重置链表的头部
                else
                    prev.next = next;//将被删除的元素的下一个元素赋给被删除的元素的前一个元素，使链表保持连续
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

    public void clear() {
        modCount++;//版本号加1
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)//清空元素
            tab[i] = null;
        size = 0;
    }

    public boolean containsValue(Object value) {
	if (value == null)//如果value为null，进入处理null value的方法
            return containsNullValue();

	Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (value.equals(e.value))//找到value，返回
                    return true;
	return false;
    }

    private boolean containsNullValue() {
	Entry[] tab = table;
        for (int i = 0; i < tab.length ; i++)
            for (Entry e = tab[i] ; e != null ; e = e.next)
                if (e.value == null)//找到value为null，返回
                    return true;
	return false;
    }

    public Object clone() {
    //克隆
        HashMap result = null;
	try {
	    result = (HashMap)super.clone();//克隆一个HashMap
	} catch (CloneNotSupportedException e) {
	    // assert false;
	}
	//初始化克隆map的属性
        result.table = new Entry[table.length];
        result.entrySet = null;
        result.modCount = 0;
        result.size = 0;
        result.init();
        result.putAllForCreate(this);

        return result;
    }

    static class Entry implements Map.Entry {//map存放的元素，即桶，本质上是一个单向链表
        final K key;//键
        V value;//值
        Entry next;//链表的下一元素
        final int hash;//哈希值

        Entry(int h, K k, V v, Entry n) {//初始化Entry
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {//获取key
            return key;
        }

        public final V getValue() {//获取value
            return value;
        }

        public final V setValue(V newValue) {//设置value
	    V oldValue = value;
            value = newValue;
            return oldValue;//返回旧value
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))//如果不是Map.Entry实例，返回false，不比较
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {//key要相等
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))//如果value也相等，则返回true
                    return true;
            }
            return false;
        }

        public final int hashCode() {//返回桶的hashcode
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }

        public final String toString() {//重写toString
            return getKey() + "=" + getValue();
        }

        void recordAccess(HashMap m) {
        }

        void recordRemoval(HashMap m) {
        }
    }

    void addEntry(int hash, K key, V value, int bucketIndex) {
	Entry e = table[bucketIndex];//获取桶的元素，也就Entry链表的表头
        table[bucketIndex] = new Entry(hash, key, value, e);//将新创建的Entry放在链表的表头
        if (size++ >= threshold)//是否扩充
            resize(2 * table.length);//扩充
    }

    void createEntry(int hash, K key, V value, int bucketIndex) {//该方法不会考虑扩充
	Entry e = table[bucketIndex];//获取桶的元素，也就Entry链表的表头
        table[bucketIndex] = new Entry(hash, key, value, e);//将新创建的Entry放在链表的表头
        size++;//大小加1
    }

    private abstract class HashIterator implements Iterator {//哈希表迭代器
        Entry next;	// next entry to return 链表的下一个元素
        int expectedModCount;	// For fast-fail 期望版本号
        int index;		// current slot 当前槽
        Entry current;	// current entry 当前entry

        HashIterator() {
            expectedModCount = modCount;//期望版本号为迭代前的当前版本号
            if (size > 0) { // 设置next为第一个桶的元素
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {//如果有下一元素，返回true
            return next != null;
        }

        final Entry nextEntry() {//迭代下一个元素
            if (modCount != expectedModCount)//版本号不等，抛出异常
                throw new ConcurrentModificationException();
            Entry e = next;
            if (e == null)//如果元素为空，抛出异常
                throw new NoSuchElementException();

            if ((next = e.next) == null) {//如果该桶的下一个元素为空，则将next设置为下一个桶的元素
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
	    current = e;//保存当前元素
            return e;
        }

        public void remove() {
            if (current == null)//如果当前元素为空，抛出异常
                throw new IllegalStateException();
            if (modCount != expectedModCount)//版本号不等，抛出异常
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);//删除key映射的元素
            expectedModCount = modCount;//更新期望版本号，保证迭代时不报错
        }

    }

    private final class ValueIterator extends HashIterator {//value迭代器
        public V next() {
            return nextEntry().value;
        }
    }

    private final class KeyIterator extends HashIterator {//key迭代器
        public K next() {
            return nextEntry().getKey();
        }
    }

    private final class EntryIterator extends HashIterator> {//Entry迭代器
        public Map.Entry next() {
            return nextEntry();
        }
    }

    // Subclass overrides these to alter behavior of views' iterator() method
    Iterator newKeyIterator()   {
        return new KeyIterator();
    }
    Iterator newValueIterator()   {
        return new ValueIterator();
    }
    Iterator> newEntryIterator()   {
        return new EntryIterator();
    }


    private transient Set> entrySet = null;//包含了键值对的set，它是一个视图

    /** 
     * 返回此映射中所包含的键的 Set 视图。 
     * 该 set 受映射的支持，所以对映射的更改将反映在该 set 中， 
     * 反之亦然。如果在对 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外）， 
     * 则迭代结果是不确定的。该 set 支持元素的移除，通过  
     * Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作 
     * 可从该映射中移除相应的映射关系。它不支持 add 或 addAll 操作。 
     */  
    public Set keySet() {//创建一个keySet
        Set ks = keySet;
        return (ks != null ? ks : (keySet = new KeySet()));
    }
 
    private final class KeySet extends AbstractSet {
        public Iterator iterator() {//key迭代器
            return newKeyIterator();
        }
        public int size() {//大小
            return size;
        }
        public boolean contains(Object o) {//是否包含了该key
            return containsKey(o);
        }
        public boolean remove(Object o) {//移除该key对应entry
            return HashMap.this.removeEntryForKey(o) != null;
        }
        public void clear() {//清空
            HashMap.this.clear();
        }
    }

    /** 
     * 返回此映射所包含的值的 Collection 视图。 
     * 该 collection 受映射的支持，所以对映射的更改将反映在该 collection 中， 
     * 反之亦然。如果在对 collection 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作除外）， 
     * 则迭代结果是不确定的。该 collection 支持元素的移除， 
     * 通过 Iterator.remove、Collection.remove、removeAll、retainAll 和 clear 操作 
     * 可从该映射中移除相应的映射关系。它不支持 add 或 addAll 操作。 
     */ 
    public Collection values() {//创建一个Values
        Collection vs = values;
        return (vs != null ? vs : (values = new Values()));
    }

    private final class Values extends AbstractCollection {
        public Iterator iterator() {//value迭代器
            return newValueIterator();
        }
        public int size() {//大小
            return size;
        }
        public boolean contains(Object o) {//是否包含了该value
            return containsValue(o);
        }
        public void clear() {//清空
            HashMap.this.clear();
        }
    }

    /** 
     * 返回此映射所包含的映射关系的 Set 视图。  
     * 该 set 受映射支持，所以对映射的更改将反映在此 set 中， 
     * 反之亦然。如果在对 set 进行迭代的同时修改了映射 
     * （通过迭代器自己的 remove 操作，或者通过在该迭代器返回的映射项上执行 setValue 操作除外）， 
     * 则迭代结果是不确定的。该 set 支持元素的移除， 
     * 通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作 
     * 可从该映射中移除相应的映射关系。它不支持 add 或 addAll 操作。 
     */  
    public Set> entrySet() {
	return entrySet0();
    }

    private Set> entrySet0() {//创建一个entrySet
        Set> es = entrySet;
        return es != null ? es : (entrySet = new EntrySet());
    }

    private final class EntrySet extends AbstractSet> {
        public Iterator> iterator() {//Entry迭代器
            return newEntryIterator();
        }
        public boolean contains(Object o) {//是否包含该entry
            if (!(o instanceof Map.Entry))//不是Map.Entry实例，返回false
                return false;
            Map.Entry e = (Map.Entry) o;//强转
            Entry candidate = getEntry(e.getKey());//通过key获取Entry
            return candidate != null && candidate.equals(e);
        }
        public boolean remove(Object o) {//移除该entry
            return removeMapping(o) != null;
        }
        public int size() {//大小
            return size;
        }
        public void clear() {//清空
            HashMap.this.clear();
        }
    }
    //序列化用
    private void writeObject(java.io.ObjectOutputStream s)
        throws IOException
    {
	Iterator> i =
	    (size > 0) ? entrySet0().iterator() : null;

	// Write out the threshold, loadfactor, and any hidden stuff
	s.defaultWriteObject();

	// Write out number of buckets
	s.writeInt(table.length);//写长度

	// Write out size (number of Mappings)
	s.writeInt(size);//写大小

        // Write out keys and values (alternating)
	if (i != null) {//写元素
	    while (i.hasNext()) {
		Map.Entry e = i.next();
		s.writeObject(e.getKey());
		s.writeObject(e.getValue());
	    }
        }
    }

    private static final long serialVersionUID = 362498820763181265L;

    private void readObject(java.io.ObjectInputStream s)
         throws IOException, ClassNotFoundException
    {
	// Read in the threshold, loadfactor, and any hidden stuff
	s.defaultReadObject();

	// Read in number of buckets and allocate the bucket array;
	int numBuckets = s.readInt();//读长度
	table = new Entry[numBuckets];

        init();  // Give subclass a chance to do its thing.

	// Read in size (number of Mappings)
	int size = s.readInt();//读大小

	// Read the keys and values, and put the mappings in the HashMap
	for (int i=0; i