public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {

        static class Node<K,V> implements Map.Entry<K,V> {
            final int hash;
            final K key;
            V value;
            Node<K,V> next;

            public final int hashCode() {
                return Objects.hashCode(key) ^ Objects.hashCode(value);
            }
        }

        final class EntrySet extends AbstractSet<Entry<K,V>> {

        }

        abstract class HashIterator {

        }

        final class EntryIterator extends HashIterator implements Iterator<Map.Entry<K,V>> {
            public final Map.Entry<K,V> next() { return nextNode(); }
        }

        /**
         * The table, initialized on first use, and resized as necessary.   第一次使用时初始化，必要时resize
         * When allocated, length is always a power of two.   长度分配时，一般是2的幂次
         */
        transient Node<K,V>[] table;

        /**
         * The default initial capacity - MUST be a power of two.   默认初始容量（必须是2的幂次）
         */
        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

        /**
         * The maximum capacity, used if a higher value is implicitly specified by either of the constructors with arguments.
         * MUST be a power of two <= 1<<30.
         */
        static final int MAXIMUM_CAPACITY = 1 << 30;

        /**
         * The load factor used when none specified in constructor.
         */
        static final float DEFAULT_LOAD_FACTOR = 0.75f;

        static final int TREEIFY_THRESHOLD = 8;

        static final int UNTREEIFY_THRESHOLD = 6;

        static final int MIN_TREEIFY_CAPACITY = 64;

        // The next size value at which to resize (capacity * load factor).  resize的下个阈值（capacity * load factor）
        int threshold;

        // The number of key-value mappings contained in this map. map中k-v数量
        transient int size;

        /**
         * Holds cached entrySet(). Note that AbstractMap fields are used for keySet() and values().
         */
        transient Set<Map.Entry<K,V>> entrySet;


    }

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        map.put(null, null);
        map.put(1, 2);
        map.put(2, 3);


/**
         * 40 invokeinterface #8 <java/util/Map.entrySet> count 1
         * 45 invokeinterface #9 <java/util/Set.iterator> count 1
         * 50 astore_2
         * 51 aload_2
         * 52 invokeinterface #10 <java/util/Iterator.hasNext> count 1
         * 57 ifeq 86 (+29)
         * 60 aload_2
         * 61 invokeinterface #11 <java/util/Iterator.next> count 1
         * 66 checkcast #12 <java/util/Map$Entry>
         * 69 astore_3
         * 70 aload_1
         * 71 aload_3
         * 72 invokeinterface #13 <java/util/Map$Entry.getKey> count 1
         * 77 invokeinterface #14 <java/util/Map.remove> count 2
         */
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            map.remove(entry.getKey());
        }



// java.util.HashMap.entrySet
    public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es;
        return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
    }

    // java.util.HashMap.EntrySet.iterator
    public final Iterator<Map.Entry<K,V>> iterator() {
        return new EntryIterator();
    }

    // java.util.HashMap.HashIterator.hasNext
    public final boolean hasNext() {
        return next != null;
    }

    // java.util.HashMap.EntryIterator.next
    public final Map.Entry<K,V> next() { return nextNode(); }

    // java.util.HashMap.HashIterator.nextNode
    final Node<K,V> nextNode() {
        Node<K,V>[] t;
        Node<K,V> e = next;
        if (modCount != expectedModCount)                                       // remove操作后，modCount+1了，但是expectedModCount没变，导致异常
            throw new ConcurrentModificationException();
        if (e == null)
            throw new NoSuchElementException();
        if ((next = (current = e).next) == null && (t = table) != null) {
            do {} while (index < t.length && (next = t[index++]) == null);
        }
        return e;
    }

// java.util.HashMap.get
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    // java.util.HashMap.hash
    // 将key的hashcode值 与 hashcode值右位移16位 做异或位运算，确定数组的索引
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    // java.util.HashMap.getNode
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {       // 数组不为空 && 指定索引位不为null
            if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))           // 数组位元素的hash值相等 && key相等 -> return数组位元素value
                return first;
            if ((e = first.next) != null) {                                                                 // 数组位元素值 与 参数不相等
                if (first instanceof TreeNode)                                                              // 如果 数组位元素 为TreeNode -> 从树中查找
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))           // 遍历链表查找元素
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }