// java.util.IdentityHashMap.put
    public V put(K key, V value) {
        final Object k = maskNull(key);

        retryAfterResize: for (;;) {
            final Object[] tab = table;
            final int len = tab.length;
            int i = hash(k, len);

            for (Object item; (item = tab[i]) != null; i = nextKeyIndex(i, len)) {                  // 索引位item!=null
                if (item == k) {                                                                    // item == key -> value替换oldValue
                    @SuppressWarnings("unchecked")
                    V oldValue = (V) tab[i + 1];
                    tab[i + 1] = value;
                    return oldValue;
                }
            }

            final int s = size + 1;
            // Use optimized form of 3 * s.
            // Next capacity is len, 2 * current capacity.
            if (s + (s << 1) > len && resize(len))
                continue retryAfterResize;

            modCount++;
            tab[i] = k;
            tab[i + 1] = value;
            size = s;
            return null;
        }
    }

// java.util.IdentityHashMap.get
    public V get(Object key) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);
        while (true) {
            Object item = tab[i];
            if (item == k)                                                                          // 如果索引位的item==key -> 返回item
                return (V) tab[i + 1];
            if (item == null)
                return null;
            i = nextKeyIndex(i, len);
        }
    }

// java.util.IdentityHashMap.keySet
    public Set<K> keySet() {
        Set<K> ks = keySet;
        if (ks == null) {
            ks = new KeySet();
            keySet = ks;
        }
        return ks;
    }

    // java.util.IdentityHashMap.KeySet
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private class KeySet extends AbstractSet<K> {

        }
    }

    // java.util.IdentityHashMap.KeySet.iterator
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private class KeySet extends AbstractSet<K> {
            public Iterator<K> iterator() {
                return new KeyIterator();
            }
        }
    }

    // java.util.IdentityHashMap.KeyIterator
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private class KeyIterator extends IdentityHashMapIterator<K> {
            public K next() {
                return (K) unmaskNull(traversalTable[nextIndex()]);
            }
        }
    }

    // java.util.IdentityHashMap.IdentityHashMapIterator
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private abstract class IdentityHashMapIterator<T> implements Iterator<T> {
            ...
        }
    }

// java.util.IdentityHashMap.entrySet
    public Set<Map.Entry<K,V>> entrySet() {
        Set<Map.Entry<K,V>> es = entrySet;
        if (es != null)
            return es;
        else
            return entrySet = new EntrySet();
    }

    // java.util.IdentityHashMap.EntrySet
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private class EntrySet extends AbstractSet<Map.Entry<K,V>> {

        }
    }

    // java.util.IdentityHashMap.EntrySet.iterator
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
            public Iterator<Map.Entry<K,V>> iterator() {
                return new EntryIterator();
            }
        }
    }

    // java.util.IdentityHashMap.EntryIterator
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private class EntryIterator extends IdentityHashMapIterator<Entry<K,V>>{
            public Map.Entry<K,V> next() {
                lastReturnedEntry = new Entry(nextIndex());
                return lastReturnedEntry;
            }

            public void remove() {
                lastReturnedIndex =
                        ((null == lastReturnedEntry) ? -1 : lastReturnedEntry.index);
                super.remove();
                lastReturnedEntry.index = lastReturnedIndex;
                lastReturnedEntry = null;
            }
        }
    }

    // java.util.IdentityHashMap.IdentityHashMapIterator
    public class IdentityHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, java.io.Serializable, Cloneable{
        private abstract class IdentityHashMapIterator<T> implements Iterator<T> {
            public boolean hasNext() {
                Object[] tab = traversalTable;
                for (int i = index; i < tab.length; i+=2) {
                    Object key = tab[i];
                    if (key != null) {
                        index = i;
                        return indexValid = true;
                    }
                }
                index = tab.length;
                return false;
            }

            protected int nextIndex() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
                if (!indexValid && !hasNext())
                    throw new NoSuchElementException();

                indexValid = false;
                lastReturnedIndex = index;
                index += 2;
                return lastReturnedIndex;
            }
        }
    }