IdentityHashMap 源代码

1、简单介绍

IdentityHashMap，并非用哈希链表来实现，底层是用数组的，比如<key, value>是存储在table[i] = key，table[i+1] = value

默认容量的大小为32，最小的容量为4，最大的容量大小为1<<29，加载因子loadFactor默认为2/3

    /**     * The initial capacity used by the no-args constructor.     * MUST be a power of two.  The value 32 corresponds to the     * (specified) expected maximum size of 21, given a load factor     * of 2/3.     */    //默认容量大小    private static final int DEFAULT_CAPACITY = 32;    /**     * The minimum capacity, used if a lower value is implicitly specified     * by either of the constructors with arguments.  The value 4 corresponds     * to an expected maximum size of 2, given a load factor of 2/3.     * MUST be a power of two.     */    //最小容量大小    private static final int MINIMUM_CAPACITY = 4;    /**     * 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<<29.     */    //最大容量大小    private static final int MAXIMUM_CAPACITY = 1 << 29;

2、初始化机制

初始化容量为2^n, 2^(n-1) < expectedMaxSize <= 2^n

    /**     * Returns the appropriate capacity for the specified expected maximum     * size.  Returns the smallest power of two between MINIMUM_CAPACITY     * and MAXIMUM_CAPACITY, inclusive, that is greater than     * (3 * expectedMaxSize)/2, if such a number exists.  Otherwise     * returns MAXIMUM_CAPACITY.  If (3 * expectedMaxSize)/2 is negative, it     * is assumed that overflow has occurred, and MAXIMUM_CAPACITY is returned.     */    private int capacity(int expectedMaxSize) {        // Compute min capacity for expectedMaxSize given a load factor of 2/3        //加载因子默认为2/3        int minCapacity = (3 * expectedMaxSize)/2;        // Compute the appropriate capacity        int result;        if (minCapacity > MAXIMUM_CAPACITY || minCapacity < 0) {            result = MAXIMUM_CAPACITY;        } else {            result = MINIMUM_CAPACITY;            //最后的result为2的n次方，            while (result < minCapacity)                result <<= 1;        }        return result;    }

3、扩容机制

扩容为原来的2倍

    /**     * Resize the table to hold given capacity.     *     * @param newCapacity the new capacity, must be a power of two.     */    private void resize(int newCapacity) {        // assert (newCapacity & -newCapacity) == newCapacity; // power of 2        //因为每个<key, value>要存储在2个位置中，所以数组需要为容量的2倍        int newLength = newCapacity * 2;        Object[] oldTable = table;        int oldLength = oldTable.length;        if (oldLength == 2*MAXIMUM_CAPACITY) { // can't expand any further            //最大只能 容量为2^29  数组长度就得为2^30            if (threshold == MAXIMUM_CAPACITY-1)                throw new IllegalStateException("Capacity exhausted.");            threshold = MAXIMUM_CAPACITY-1;  // Gigantic map!            return;        }        if (oldLength >= newLength)            return;        Object[] newTable = new Object[newLength];        //threshold是2/3cap        threshold = newLength / 3;        for (int j = 0; j < oldLength; j += 2) {            Object key = oldTable[j];            if (key != null) {                Object value = oldTable[j+1];                //将oldTable设为null，用于垃圾回收                oldTable[j] = null;                oldTable[j+1] = null;                int i = hash(key, newLength);                while (newTable[i] != null)                    i = nextKeyIndex(i, newLength);                //将值设在新的table中                newTable[i] = key;                newTable[i + 1] = value;            }        }        table = newTable;    }

4、特殊地方

当key为null时，其实不是真的将key设为null，而是替换成NULL_KEY对象

    /**     * Value representing null keys inside tables.     */    //空的key    static final Object NULL_KEY = new Object();    /**     * Use NULL_KEY for key if it is null.     */    //如果为空，则用NULL_KEY    private static Object maskNull(Object key) {        return (key == null ? NULL_KEY : key);    }    /**     * Returns internal representation of null key back to caller as null.     */    //如果为NULL_KEY，则返回null    static final Object unmaskNull(Object key) {        return (key == NULL_KEY ? null : key);    }

5、解决hash冲突方法

其实就是往后移2位，直到有空的就将键值对放到里面【线性探测器】

    //获取下一个key的下标index    private static int nextKeyIndex(int i, int len) {        return (i + 2 < len ? i + 2 : 0);    }

6、删除情况

删除一个元素时，需要将当初冲突往后移的键值对往前移

 /**     * Rehash all possibly-colliding entries following a     * deletion. This preserves the linear-probe     * collision properties required by get, put, etc.     *     * @param d the index of a newly empty deleted slot     */    //删除一个键值对后，当初冲突的键值对需要往前移    private void closeDeletion(int d) {        // Adapted from Knuth Section 6.4 Algorithm R        Object[] tab = table;        int len = tab.length;        // Look for items to swap into newly vacated slot        // starting at index immediately following deletion,        // and continuing until a null slot is seen, indicating        // the end of a run of possibly-colliding keys.        Object item;        //冲突的键值对往前移        for (int i = nextKeyIndex(d, len); (item = tab[i]) != null;             i = nextKeyIndex(i, len) ) {            // The following test triggers if the item at slot i (which            // hashes to be at slot r) should take the spot vacated by d.            // If so, we swap it in, and then continue with d now at the            // newly vacated i.  This process will terminate when we hit            // the null slot at the end of this run.            // The test is messy because we are using a circular table.            int r = hash(item, len);            if ((i < r && (r <= d || d <= i)) || (r <= d && d <= i)) {                tab[d] = item;                tab[d + 1] = tab[i + 1];                tab[i] = null;                tab[i + 1] = null;                d = i;            }        }    }

7、源代码

/* * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.util;import java.io.*;import java.lang.reflect.Array;import java.util.function.BiConsumer;import java.util.function.BiFunction;import java.util.function.Consumer;/** * This class implements the <tt>Map</tt> interface with a hash table, using * reference-equality in place of object-equality when comparing keys (and * values).  In other words, in an <tt>IdentityHashMap</tt>, two keys * <tt>k1</tt> and <tt>k2</tt> are considered equal if and only if * <tt>(k1==k2)</tt>.  (In normal <tt>Map</tt> implementations (like * <tt>HashMap</tt>) two keys <tt>k1</tt> and <tt>k2</tt> are considered equal * if and only if <tt>(k1==null ? k2==null : k1.equals(k2))</tt>.) * * <p><b>This class is <i>not</i> a general-purpose <tt>Map</tt> * implementation!  While this class implements the <tt>Map</tt> interface, it * intentionally violates <tt>Map's</tt> general contract, which mandates the * use of the <tt>equals</tt> method when comparing objects.  This class is * designed for use only in the rare cases wherein reference-equality * semantics are required.</b> * * <p>A typical use of this class is <i>topology-preserving object graph * transformations</i>, such as serialization or deep-copying.  To perform such * a transformation, a program must maintain a "node table" that keeps track * of all the object references that have already been processed.  The node * table must not equate distinct objects even if they happen to be equal. * Another typical use of this class is to maintain <i>proxy objects</i>.  For * example, a debugging facility might wish to maintain a proxy object for * each object in the program being debugged. * * <p>This class provides all of the optional map operations, and permits * <tt>null</tt> values and the <tt>null</tt> key.  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. * * <p>This class provides constant-time performance for the basic * operations (<tt>get</tt> and <tt>put</tt>), assuming the system * identity hash function ({@link System#identityHashCode(Object)}) * disperses elements properly among the buckets. * * <p>This class has one tuning parameter (which affects performance but not * semantics): <i>expected maximum size</i>.  This parameter is the maximum * number of key-value mappings that the map is expected to hold.  Internally, * this parameter is used to determine the number of buckets initially * comprising the hash table.  The precise relationship between the expected * maximum size and the number of buckets is unspecified. * * <p>If the size of the map (the number of key-value mappings) sufficiently * exceeds the expected maximum size, the number of buckets is increased * Increasing the number of buckets ("rehashing") may be fairly expensive, so * it pays to create identity hash maps with a sufficiently large expected * maximum size.  On the other hand, iteration over collection views requires * time proportional to the number of buckets in the hash table, so it * pays not to set the expected maximum size too high if you are especially * concerned with iteration performance or memory usage. * * <p><strong>Note that this implementation is not synchronized.</strong> * If multiple threads access an identity hash map concurrently, and at * least one of the threads modifies the map structurally, it <i>must</i> * be synchronized externally.  (A structural modification is any operation * that adds or deletes one or more mappings; merely changing the value * associated with a key that an instance already contains is not a * structural modification.)  This is typically accomplished by * synchronizing on some object that naturally encapsulates the map. * * If no such object exists, the map should be "wrapped" using the * {@link Collections#synchronizedMap Collections.synchronizedMap} * method.  This is best done at creation time, to prevent accidental * unsynchronized access to the map:<pre> *   Map m = Collections.synchronizedMap(new IdentityHashMap(...));</pre> * * <p>The iterators returned by the <tt>iterator</tt> method of the * collections returned by all of this class's "collection view * methods" are <i>fail-fast</i>: if the map is structurally modified * at any time after the iterator is created, in any way except * through the iterator's own <tt>remove</tt> method, the iterator * will throw a {@link ConcurrentModificationException}.  Thus, in the * face of concurrent modification, the iterator fails quickly and * cleanly, rather than risking arbitrary, non-deterministic behavior * at an undetermined time in the future. * * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the * presence of unsynchronized concurrent modification.  Fail-fast iterators * throw <tt>ConcurrentModificationException</tt> on a best-effort basis. * Therefore, it would be wrong to write a program that depended on this * exception for its correctness: <i>fail-fast iterators should be used only * to detect bugs.</i> * * <p>Implementation note: This is a simple <i>linear-probe</i> hash table, * as described for example in texts by Sedgewick and Knuth.  The array * alternates holding keys and values.  (This has better locality for large * tables than does using separate arrays.)  For many JRE implementations * and operation mixes, this class will yield better performance than * {@link HashMap} (which uses <i>chaining</i> rather than linear-probing). * * <p>This class is a member of the * <a href="{@docRoot}/../technotes/guides/collections/index.html"> * Java Collections Framework</a>. * * @see     System#identityHashCode(Object) * @see     Object#hashCode() * @see     Collection * @see     Map * @see     HashMap * @see     TreeMap * @author  Doug Lea and Josh Bloch * @since   1.4 *//*此类利用哈希表实现 Map 接口，比较键（和值）时使用引用相等性代替对象相等性。换句话说，在 IdentityHashMap 中，当且仅当 (k1==k2) 时，才认为两个键 k1 和 k2 相等（在正常 Map 实现（如 HashMap）中，当且仅当满足下列条件时才认为两个键 k1 和 k2 相等：(k1==null ? k2==null : e1.equals(e2))）。此类不是 通用 Map 实现！此类实现 Map 接口时，它有意违反 Map 的常规协定，该协定在比较对象时强制使用 equals 方法。此类设计仅用于其中需要引用相等性语义的罕见情况。此类的典型用法是拓扑保留对象图形转换，如序列化或深层复制。要执行这样的转换，程序必须维护用于跟踪所有已处理对象引用的“节点表”。节点表一定不等于不同对象，即使它们偶然相等也如此。此类的另一种典型用法是维护代理对象。例如，调试设施可能希望为正在调试程序中的每个对象维护代理对象。此类提供所有的可选映射操作，并且允许 null 值和 null 键。此类对映射的顺序不提供任何保证；特别是不保证顺序随时间的推移保持不变。此类提供基本操作（get 和 put）的稳定性能，假定系统标识了将桶间元素正确分开的哈希函数(System.identityHashCode(Object))。此类具有一个调整参数（影响性能但不影响语义）：expected maximum size。此参数是希望映射保持的键值映射关系最大数。在内部，此参数用于确定最初组成哈希表的桶数。未指定所期望的最大数量和桶数之间的确切关系。如果映射的大小（键值映射关系数）已经超过期望的最大数量，则桶数会增加，增加桶数（“重新哈希”）可能相当昂贵，因此创建具有足够大的期望最大数量的标识哈希映射更合算。另一方面，对 collection 视图进行迭代所需的时间与哈希表中的桶数成正比，所以如果特别注重迭代性能或内存使用，则不宜将期望的最大数量设置得过高。注意，此实现不是同步的。如果多个线程同时访问标识哈希映射，并且其中至少一个线程从结构上修改了该映射，则其必须保持外部同步（结构上的修改是指添加或删除一个或多个映射关系的操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的不同步访问，如下所示：     Map m = Collections.synchronizedMap(new HashMap(...)); 由所有此类的“collection 视图方法”     所返回的collections的iterator 方法返回的迭代器都是快速失败 的：在迭代器创建之后，如果从结构上对映射进行修改，     除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出     ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，     而不冒在将来不确定的时间任意发生不确定行为的风险。注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何强有力的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。实现注意事项：此为简单的线性探头 哈希表，如 Sedgewick 和 Knuth 原文示例中所述。该数组交替保持键和值（对于大型表来说，它比使用独立组保持键和值更具优势）。对于多数 JRE 实现和混合操作，此类比 HashMap（它使用链而不使用线性探头）能产生更好的性能 */public class IdentityHashMap<K,V>    extends AbstractMap<K,V>    implements Map<K,V>, java.io.Serializable, Cloneable{    /**     * The initial capacity used by the no-args constructor.     * MUST be a power of two.  The value 32 corresponds to the     * (specified) expected maximum size of 21, given a load factor     * of 2/3.     */    //默认容量大小    private static final int DEFAULT_CAPACITY = 32;    /**     * The minimum capacity, used if a lower value is implicitly specified     * by either of the constructors with arguments.  The value 4 corresponds     * to an expected maximum size of 2, given a load factor of 2/3.     * MUST be a power of two.     */    //最小容量大小    private static final int MINIMUM_CAPACITY = 4;    /**     * 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<<29.     */    //最大容量大小    private static final int MAXIMUM_CAPACITY = 1 << 29;    /**     * The table, resized as necessary. Length MUST always be a power of two.     */    //缓冲    transient Object[] table; // non-private to simplify nested class access    /**     * The number of key-value mappings contained in this identity hash map.     *     * @serial     */    //大小    int size;    /**     * The number of modifications, to support fast-fail iterators     */    transient int modCount;    /**     * The next size value at which to resize (capacity * load factor).     */    //阀值    private transient int threshold;    /**     * Value representing null keys inside tables.     */    //空的key    static final Object NULL_KEY = new Object();    /**     * Use NULL_KEY for key if it is null.     */    //如果为空，则用NULL_KEY    private static Object maskNull(Object key) {        return (key == null ? NULL_KEY : key);    }    /**     * Returns internal representation of null key back to caller as null.     */    //如果为NULL_KEY，则返回null    static final Object unmaskNull(Object key) {        return (key == NULL_KEY ? null : key);    }    /**     * Constructs a new, empty identity hash map with a default expected     * maximum size (21).     */    public IdentityHashMap() {        init(DEFAULT_CAPACITY);    }    /**     * Constructs a new, empty map with the specified expected maximum size.     * Putting more than the expected number of key-value mappings into     * the map may cause the internal data structure to grow, which may be     * somewhat time-consuming.     *     * @param expectedMaxSize the expected maximum size of the map     * @throws IllegalArgumentException if <tt>expectedMaxSize</tt> is negative     */    public IdentityHashMap(int expectedMaxSize) {        if (expectedMaxSize < 0)            throw new IllegalArgumentException("expectedMaxSize is negative: "                                               + expectedMaxSize);        init(capacity(expectedMaxSize));    }    /**     * Returns the appropriate capacity for the specified expected maximum     * size.  Returns the smallest power of two between MINIMUM_CAPACITY     * and MAXIMUM_CAPACITY, inclusive, that is greater than     * (3 * expectedMaxSize)/2, if such a number exists.  Otherwise     * returns MAXIMUM_CAPACITY.  If (3 * expectedMaxSize)/2 is negative, it     * is assumed that overflow has occurred, and MAXIMUM_CAPACITY is returned.     */    private int capacity(int expectedMaxSize) {        // Compute min capacity for expectedMaxSize given a load factor of 2/3        //加载因子默认为2/3        int minCapacity = (3 * expectedMaxSize)/2;        // Compute the appropriate capacity        int result;        if (minCapacity > MAXIMUM_CAPACITY || minCapacity < 0) {            result = MAXIMUM_CAPACITY;        } else {            result = MINIMUM_CAPACITY;            //最后的result为2的倍数，            while (result < minCapacity)                result <<= 1;        }        return result;    }    /**     * Initializes object to be an empty map with the specified initial     * capacity, which is assumed to be a power of two between     * MINIMUM_CAPACITY and MAXIMUM_CAPACITY inclusive.     */    private void init(int initCapacity) {        // assert (initCapacity & -initCapacity) == initCapacity; // power of 2        // assert initCapacity >= MINIMUM_CAPACITY;        // assert initCapacity <= MAXIMUM_CAPACITY;        threshold = (initCapacity * 2)/3;        table = new Object[2 * initCapacity];    }    /**     * Constructs a new identity hash map containing the keys-value mappings     * in the specified map.     *     * @param m the map whose mappings are to be placed into this map     * @throws NullPointerException if the specified map is null     */    public IdentityHashMap(Map<? extends K, ? extends V> m) {        // Allow for a bit of growth        this((int) ((1 + m.size()) * 1.1));        putAll(m);    }    /**     * Returns the number of key-value mappings in this identity hash map.     *     * @return the number of key-value mappings in this map     */    public int size() {        return size;    }    /**     * Returns <tt>true</tt> if this identity hash map contains no key-value     * mappings.     *     * @return <tt>true</tt> if this identity hash map contains no key-value     *         mappings     */    public boolean isEmpty() {        return size == 0;    }    /**     * Returns index for Object x.     */    private static int hash(Object x, int length) {        int h = System.identityHashCode(x);        // Multiply by -127, and left-shift to use least bit as part of hash        return ((h << 1) - (h << 8)) & (length - 1);    }    /**     * Circularly traverses table of size len.     */    //获取下一个key的下标index    private static int nextKeyIndex(int i, int len) {        return (i + 2 < len ? i + 2 : 0);    }    /**     * Returns the value to which the specified key is mapped,     * or {@code null} if this map contains no mapping for the key.     *     * <p>More formally, if this map contains a mapping from a key     * {@code k} to a value {@code v} such that {@code (key == k)},     * then this method returns {@code v}; otherwise it returns     * {@code null}.  (There can be at most one such mapping.)     *     * <p>A return value of {@code null} does not <i>necessarily</i>     * indicate that the map contains no mapping for the key; it's also     * possible that the map explicitly maps the key to {@code null}.     * The {@link #containsKey containsKey} operation may be used to     * distinguish these two cases.     *     * @see #put(Object, Object)     */    //通过key获取value    @SuppressWarnings("unchecked")    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)                //获取value                return (V) tab[i + 1];            if (item == null)                return null;            i = nextKeyIndex(i, len);        }    }    /**     * Tests whether the specified object reference is a key in this identity     * hash map.     *     * @param   key   possible key     * @return  <code>true</code> if the specified object reference is a key     *          in this map     * @see     #containsValue(Object)     */    //判断是否包含key    public boolean containsKey(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)                return true;            if (item == null)                return false;            i = nextKeyIndex(i, len);        }    }    /**     * Tests whether the specified object reference is a value in this identity     * hash map.     *     * @param value value whose presence in this map is to be tested     * @return <tt>true</tt> if this map maps one or more keys to the     *         specified object reference     * @see     #containsKey(Object)     */    //是否包含值为value的键值对    public boolean containsValue(Object value) {        Object[] tab = table;        for (int i = 1; i < tab.length; i += 2)            //通过遍历tab            if (tab[i] == value && tab[i - 1] != null)                return true;        return false;    }    /**     * Tests if the specified key-value mapping is in the map.     *     * @param   key   possible key     * @param   value possible value     * @return  <code>true</code> if and only if the specified key-value     *          mapping is in the map     */    //判断是否有该键值对    private boolean containsMapping(Object key, Object value) {        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)                return tab[i + 1] == value;            if (item == null)                return false;            i = nextKeyIndex(i, len);        }    }    /**     * Associates the specified value with the specified key in this identity     * hash map.  If the map previously contained a mapping for the key, the     * old value is replaced.     *     * @param key the key with which the specified value is to be associated     * @param value the value to be associated with the specified key     * @return the previous value associated with <tt>key</tt>, or     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.     *         (A <tt>null</tt> return can also indicate that the map     *         previously associated <tt>null</tt> with <tt>key</tt>.)     * @see     Object#equals(Object)     * @see     #get(Object)     * @see     #containsKey(Object)     */    //添加键值对    public V put(K key, V value) {        Object k = maskNull(key);        Object[] tab = table;        int len = tab.length;        int i = hash(k, len);        Object item;        //直到找到不为null的位置        while ( (item = tab[i]) != null) {            if (item == k) {                @SuppressWarnings("unchecked")                    V oldValue = (V) tab[i + 1];                tab[i + 1] = value;                return oldValue;            }            i = nextKeyIndex(i, len);        }        modCount++;        //k, value设在相邻的2个位置        tab[i] = k;        tab[i + 1] = value;        if (++size >= threshold)            resize(len); // len == 2 * current capacity.        return null;    }    /**     * Resize the table to hold given capacity.     *     * @param newCapacity the new capacity, must be a power of two.     */    private void resize(int newCapacity) {        // assert (newCapacity & -newCapacity) == newCapacity; // power of 2        //因为每个<key, value>要存储在2个位置中，所以数组需要为容量的2倍        int newLength = newCapacity * 2;        Object[] oldTable = table;        int oldLength = oldTable.length;        if (oldLength == 2*MAXIMUM_CAPACITY) { // can't expand any further            //最大只能 容量为2^29  数组长度就得为2^30            if (threshold == MAXIMUM_CAPACITY-1)                throw new IllegalStateException("Capacity exhausted.");            threshold = MAXIMUM_CAPACITY-1;  // Gigantic map!            return;        }        if (oldLength >= newLength)            return;        Object[] newTable = new Object[newLength];        //threshold是2/3cap        threshold = newLength / 3;        for (int j = 0; j < oldLength; j += 2) {            Object key = oldTable[j];            if (key != null) {                Object value = oldTable[j+1];                //将oldTable设为null，用于垃圾回收                oldTable[j] = null;                oldTable[j+1] = null;                int i = hash(key, newLength);                while (newTable[i] != null)                    i = nextKeyIndex(i, newLength);                //将值设在新的table中                newTable[i] = key;                newTable[i + 1] = value;            }        }        table = newTable;    }    /**     * Copies all of the mappings from the specified map to this map.     * These mappings will replace any mappings that this map had for     * any of the keys currently in the specified map.     *     * @param m mappings to be stored in this map     * @throws NullPointerException if the specified map is null     */    //将m中的键值对复制到本map中    public void putAll(Map<? extends K, ? extends V> m) {        int n = m.size();        if (n == 0)            return;        if (n > threshold) // conservatively pre-expand            resize(capacity(n));        //循环put        for (Entry<? extends K, ? extends V> e : m.entrySet())            put(e.getKey(), e.getValue());    }    /**     * Removes the mapping for this key from this map if present.     *     * @param key key whose mapping is to be removed from the map     * @return the previous value associated with <tt>key</tt>, or     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.     *         (A <tt>null</tt> return can also indicate that the map     *         previously associated <tt>null</tt> with <tt>key</tt>.)     */    //移除掉键为key的键值对    public V remove(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) {                //找到该键值对                modCount++;                size--;                @SuppressWarnings("unchecked")                    V oldValue = (V) tab[i + 1];                //将key和value设为null                tab[i + 1] = null;                tab[i] = null;                closeDeletion(i);                return oldValue;            }            if (item == null)                return null;            i = nextKeyIndex(i, len);        }    }    /**     * Removes the specified key-value mapping from the map if it is present.     *     * @param   key   possible key     * @param   value possible value     * @return  <code>true</code> if and only if the specified key-value     *          mapping was in the map     */    //删除掉键值对，必须key,value都相等    private boolean removeMapping(Object key, Object value) {        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) {                if (tab[i + 1] != value)                    return false;                modCount++;                size--;                tab[i] = null;                tab[i + 1] = null;                closeDeletion(i);                return true;            }            if (item == null)                return false;            i = nextKeyIndex(i, len);        }    }    /**     * Rehash all possibly-colliding entries following a     * deletion. This preserves the linear-probe     * collision properties required by get, put, etc.     *     * @param d the index of a newly empty deleted slot     */    //删除一个键值对后，当初冲突的键值对需要往前移    private void closeDeletion(int d) {        // Adapted from Knuth Section 6.4 Algorithm R        Object[] tab = table;        int len = tab.length;        // Look for items to swap into newly vacated slot        // starting at index immediately following deletion,        // and continuing until a null slot is seen, indicating        // the end of a run of possibly-colliding keys.        Object item;        //冲突的键值对往前移        for (int i = nextKeyIndex(d, len); (item = tab[i]) != null;             i = nextKeyIndex(i, len) ) {            // The following test triggers if the item at slot i (which            // hashes to be at slot r) should take the spot vacated by d.            // If so, we swap it in, and then continue with d now at the            // newly vacated i.  This process will terminate when we hit            // the null slot at the end of this run.            // The test is messy because we are using a circular table.            int r = hash(item, len);            if ((i < r && (r <= d || d <= i)) || (r <= d && d <= i)) {                tab[d] = item;                tab[d + 1] = tab[i + 1];                tab[i] = null;                tab[i + 1] = null;                d = i;            }        }    }    /**     * Removes all of the mappings from this map.     * The map will be empty after this call returns.     */    //遍历、清除    public void clear() {        modCount++;        Object[] tab = table;        for (int i = 0; i < tab.length; i++)            tab[i] = null;        size = 0;    }    /**     * Compares the specified object with this map for equality.  Returns     * <tt>true</tt> if the given object is also a map and the two maps     * represent identical object-reference mappings.  More formally, this     * map is equal to another map <tt>m</tt> if and only if     * <tt>this.entrySet().equals(m.entrySet())</tt>.     *     * <p><b>Owing to the reference-equality-based semantics of this map it is     * possible that the symmetry and transitivity requirements of the     * <tt>Object.equals</tt> contract may be violated if this map is compared     * to a normal map.  However, the <tt>Object.equals</tt> contract is     * guaranteed to hold among <tt>IdentityHashMap</tt> instances.</b>     *     * @param  o object to be compared for equality with this map     * @return <tt>true</tt> if the specified object is equal to this map     * @see Object#equals(Object)     */    public boolean equals(Object o) {        if (o == this) {            return true;        } else if (o instanceof IdentityHashMap) {            IdentityHashMap<?,?> m = (IdentityHashMap<?,?>) o;            //大小不等返回false            if (m.size() != size)                return false;            Object[] tab = m.table;            for (int i = 0; i < tab.length; i+=2) {                Object k = tab[i];                //需要key、value都相等                if (k != null && !containsMapping(k, tab[i + 1]))                    return false;            }            return true;        } else if (o instanceof Map) {            Map<?,?> m = (Map<?,?>)o;            return entrySet().equals(m.entrySet());        } else {            return false;  // o is not a Map        }    }    /**     * Returns the hash code value for this map.  The hash code of a map is     * defined to be the sum of the hash codes of each entry in the map's     * <tt>entrySet()</tt> view.  This ensures that <tt>m1.equals(m2)</tt>     * implies that <tt>m1.hashCode()==m2.hashCode()</tt> for any two     * <tt>IdentityHashMap</tt> instances <tt>m1</tt> and <tt>m2</tt>, as     * required by the general contract of {@link Object#hashCode}.     *     * <p><b>Owing to the reference-equality-based semantics of the     * <tt>Map.Entry</tt> instances in the set returned by this map's     * <tt>entrySet</tt> method, it is possible that the contractual     * requirement of <tt>Object.hashCode</tt> mentioned in the previous     * paragraph will be violated if one of the two objects being compared is     * an <tt>IdentityHashMap</tt> instance and the other is a normal map.</b>     *     * @return the hash code value for this map     * @see Object#equals(Object)     * @see #equals(Object)     */    public int hashCode() {        int result = 0;        Object[] tab = table;        //遍历，将所有key和value的hash相加        for (int i = 0; i < tab.length; i +=2) {            Object key = tab[i];            if (key != null) {                Object k = unmaskNull(key);                result += System.identityHashCode(k) ^                          System.identityHashCode(tab[i + 1]);            }        }        return result;    }    /**     * Returns a shallow copy of this identity hash map: the keys and values     * themselves are not cloned.     *     * @return a shallow copy of this map     */    public Object clone() {        try {            IdentityHashMap<?,?> m = (IdentityHashMap<?,?>) super.clone();            m.entrySet = null;            m.table = table.clone();            return m;        } catch (CloneNotSupportedException e) {            throw new InternalError(e);        }    }    //迭代器    private abstract class IdentityHashMapIterator<T> implements Iterator<T> {        //当前的下标        int index = (size != 0 ? 0 : table.length); // current slot.        int expectedModCount = modCount; // to support fast-fail        //最后返回的键值对的下标        int lastReturnedIndex = -1;      // to allow remove()        //当下标的位置为null时就设为false        boolean indexValid; // To avoid unnecessary next computation        //table的引用        Object[] traversalTable = table; // reference to main table or copy        //有下一个元素则返回true        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;        }        //移除掉键值对        public void remove() {            if (lastReturnedIndex == -1)                throw new IllegalStateException();            if (modCount != expectedModCount)                throw new ConcurrentModificationException();            expectedModCount = ++modCount;            int deletedSlot = lastReturnedIndex;            lastReturnedIndex = -1;            // back up index to revisit new contents after deletion            index = deletedSlot;            indexValid = false;            // Removal code proceeds as in closeDeletion except that            // it must catch the rare case where an element already            // seen is swapped into a vacant slot that will be later            // traversed by this iterator. We cannot allow future            // next() calls to return it again.  The likelihood of            // this occurring under 2/3 load factor is very slim, but            // when it does happen, we must make a copy of the rest of            // the table to use for the rest of the traversal. Since            // this can only happen when we are near the end of the table,            // even in these rare cases, this is not very expensive in            // time or space.            Object[] tab = traversalTable;            int len = tab.length;            int d = deletedSlot;            Object key = tab[d];            //相应的键值对设置为null            tab[d] = null;        // vacate the slot            tab[d + 1] = null;            // If traversing a copy, remove in real table.            // We can skip gap-closure on copy.            //如果是本map中的缓冲table的引用，则调用本map中的remove            if (tab != IdentityHashMap.this.table) {                IdentityHashMap.this.remove(key);                expectedModCount = modCount;                return;            }            size--;            //需要将冲突时的那些键值对往前移            Object item;            for (int i = nextKeyIndex(d, len); (item = tab[i]) != null;                 i = nextKeyIndex(i, len)) {                int r = hash(item, len);                // See closeDeletion for explanation of this conditional                if ((i < r && (r <= d || d <= i)) ||                    (r <= d && d <= i)) {                    // If we are about to swap an already-seen element                    // into a slot that may later be returned by next(),                    // then clone the rest of table for use in future                    // next() calls. It is OK that our copy will have                    // a gap in the "wrong" place, since it will never                    // be used for searching anyway.                    if (i < deletedSlot && d >= deletedSlot &&                        traversalTable == IdentityHashMap.this.table) {                        //i为d的下一个位置的下标，i已经超过table的容量，在d前面，这时候将剩下的键值对移到前面                        int remaining = len - deletedSlot;                        Object[] newTable = new Object[remaining];                        System.arraycopy(tab, deletedSlot,                                         newTable, 0, remaining);                        traversalTable = newTable;                        index = 0;                    }                    tab[d] = item;                    tab[d + 1] = tab[i + 1];                    tab[i] = null;                    tab[i + 1] = null;                    d = i;                }            }        }    }    //key的迭代器    private class KeyIterator extends IdentityHashMapIterator<K> {        @SuppressWarnings("unchecked")        public K next() {            return (K) unmaskNull(traversalTable[nextIndex()]);        }    }    //value的迭代器    private class ValueIterator extends IdentityHashMapIterator<V> {        @SuppressWarnings("unchecked")        public V next() {            return (V) traversalTable[nextIndex() + 1];        }    }    //键值对的迭代器    private class EntryIterator        extends IdentityHashMapIterator<Map.Entry<K,V>>    {        //记录上一次return的实体        private Entry lastReturnedEntry = null;        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;        }        //键值对迭代器的实体        private class Entry implements Map.Entry<K,V> {            private int index;            private Entry(int index) {                this.index = index;            }            //得到key            @SuppressWarnings("unchecked")            public K getKey() {                checkIndexForEntryUse();                return (K) unmaskNull(traversalTable[index]);            }            //得到value            @SuppressWarnings("unchecked")            public V getValue() {                checkIndexForEntryUse();                return (V) traversalTable[index+1];            }            //设置value            @SuppressWarnings("unchecked")            public V setValue(V value) {                checkIndexForEntryUse();                V oldValue = (V) traversalTable[index+1];                traversalTable[index+1] = value;                // if shadowing, force into main table                if (traversalTable != IdentityHashMap.this.table)                    put((K) traversalTable[index], value);                return oldValue;            }            public boolean equals(Object o) {                if (index < 0)                    return super.equals(o);                if (!(o instanceof Map.Entry))                    return false;                Map.Entry<?,?> e = (Map.Entry<?,?>)o;                return (e.getKey() == unmaskNull(traversalTable[index]) &&                       e.getValue() == traversalTable[index+1]);            }            public int hashCode() {                if (lastReturnedIndex < 0)                    return super.hashCode();                return (System.identityHashCode(unmaskNull(traversalTable[index])) ^                       System.identityHashCode(traversalTable[index+1]));            }            public String toString() {                if (index < 0)                    return super.toString();                return (unmaskNull(traversalTable[index]) + "="                        + traversalTable[index+1]);            }            private void checkIndexForEntryUse() {                if (index < 0)                    throw new IllegalStateException("Entry was removed");            }        }    }    // Views    /**     * This field is initialized to contain an instance of the entry set     * view the first time this view is requested.  The view is stateless,     * so there's no reason to create more than one.     */    private transient Set<Map.Entry<K,V>> entrySet = null;    /**     * Returns an identity-based set view of the keys contained in this map.     * The set is backed by the map, so changes to the map are reflected in     * the set, and vice-versa.  If the map is modified while an iteration     * over the set is in progress, the results of the iteration are     * undefined.  The set supports element removal, which removes the     * corresponding mapping from the map, via the <tt>Iterator.remove</tt>,     * <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt>, and     * <tt>clear</tt> methods.  It does not support the <tt>add</tt> or     * <tt>addAll</tt> methods.     *     * <p><b>While the object returned by this method implements the     * <tt>Set</tt> interface, it does <i>not</i> obey <tt>Set's</tt> general     * contract.  Like its backing map, the set returned by this method     * defines element equality as reference-equality rather than     * object-equality.  This affects the behavior of its <tt>contains</tt>,     * <tt>remove</tt>, <tt>containsAll</tt>, <tt>equals</tt>, and     * <tt>hashCode</tt> methods.</b>     *     * <p><b>The <tt>equals</tt> method of the returned set returns <tt>true</tt>     * only if the specified object is a set containing exactly the same     * object references as the returned set.  The symmetry and transitivity     * requirements of the <tt>Object.equals</tt> contract may be violated if     * the set returned by this method is compared to a normal set.  However,     * the <tt>Object.equals</tt> contract is guaranteed to hold among sets     * returned by this method.</b>     *     * <p>The <tt>hashCode</tt> method of the returned set returns the sum of     * the <i>identity hashcodes</i> of the elements in the set, rather than     * the sum of their hashcodes.  This is mandated by the change in the     * semantics of the <tt>equals</tt> method, in order to enforce the     * general contract of the <tt>Object.hashCode</tt> method among sets     * returned by this method.     *     * @return an identity-based set view of the keys contained in this map     * @see Object#equals(Object)     * @see System#identityHashCode(Object)     */    //返回keySet    public Set<K> keySet() {        Set<K> ks = keySet;        if (ks != null)            return ks;        else            return keySet = new KeySet();    }    private class KeySet extends AbstractSet<K> {        public Iterator<K> iterator() {            return new KeyIterator();        }        public int size() {            return size;        }        public boolean contains(Object o) {            return containsKey(o);        }        public boolean remove(Object o) {            int oldSize = size;            IdentityHashMap.this.remove(o);            return size != oldSize;        }        /*         * Must revert from AbstractSet's impl to AbstractCollection's, as         * the former contains an optimization that results in incorrect         * behavior when c is a smaller "normal" (non-identity-based) Set.         */        public boolean removeAll(Collection<?> c) {            Objects.requireNonNull(c);            boolean modified = false;            //获取迭代器，当找到的时候就remove            for (Iterator<K> i = iterator(); i.hasNext(); ) {                if (c.contains(i.next())) {                    i.remove();                    modified = true;                }            }            return modified;        }        public void clear() {            IdentityHashMap.this.clear();        }        public int hashCode() {            int result = 0;            for (K key : this)                result += System.identityHashCode(key);            return result;        }        public Object[] toArray() {            return toArray(new Object[0]);        }        @SuppressWarnings("unchecked")        public <T> T[] toArray(T[] a) {            int expectedModCount = modCount;            int size = size();            //创建数组            if (a.length < size)                a = (T[]) Array.newInstance(a.getClass().getComponentType(), size);            Object[] tab = table;            int ti = 0;            for (int si = 0; si < tab.length; si += 2) {                //设置key                Object key;                if ((key = tab[si]) != null) { // key present ?                    // more elements than expected -> concurrent modification from other thread                    if (ti >= size) {                        throw new ConcurrentModificationException();                    }                    a[ti++] = (T) unmaskNull(key); // unmask key                }            }            // fewer elements than expected or concurrent modification from other thread detected            if (ti < size || expectedModCount != modCount) {                throw new ConcurrentModificationException();            }            // final null marker as per spec            if (ti < a.length) {                a[ti] = null;            }            return a;        }        public Spliterator<K> spliterator() {            return new KeySpliterator<>(IdentityHashMap.this, 0, -1, 0, 0);        }    }    /**     * Returns a {@link Collection} view of the values contained in this map.     * The collection is backed by the map, so changes to the map are     * reflected in the collection, and vice-versa.  If the map is     * modified while an iteration over the collection is in progress,     * the results of the iteration are undefined.  The collection     * supports element removal, which removes the corresponding     * mapping from the map, via the <tt>Iterator.remove</tt>,     * <tt>Collection.remove</tt>, <tt>removeAll</tt>,     * <tt>retainAll</tt> and <tt>clear</tt> methods.  It does not     * support the <tt>add</tt> or <tt>addAll</tt> methods.     *     * <p><b>While the object returned by this method implements the     * <tt>Collection</tt> interface, it does <i>not</i> obey     * <tt>Collection's</tt> general contract.  Like its backing map,     * the collection returned by this method defines element equality as     * reference-equality rather than object-equality.  This affects the     * behavior of its <tt>contains</tt>, <tt>remove</tt> and     * <tt>containsAll</tt> methods.</b>     */    //获取存储value的容器    public Collection<V> values() {        Collection<V> vs = values;        if (vs != null)            return vs;        else            return values = new Values();    }    private class Values extends AbstractCollection<V> {        public Iterator<V> iterator() {            return new ValueIterator();        }        public int size() {            return size;        }        public boolean contains(Object o) {            return containsValue(o);        }        public boolean remove(Object o) {            for (Iterator<V> i = iterator(); i.hasNext(); ) {                if (i.next() == o) {                    i.remove();                    return true;                }            }            return false;        }        public void clear() {            IdentityHashMap.this.clear();        }        public Object[] toArray() {            return toArray(new Object[0]);        }        @SuppressWarnings("unchecked")        public <T> T[] toArray(T[] a) {            int expectedModCount = modCount;            int size = size();            if (a.length < size)                a = (T[]) Array.newInstance(a.getClass().getComponentType(), size);            Object[] tab = table;            int ti = 0;            for (int si = 0; si < tab.length; si += 2) {                //设置value                if (tab[si] != null) { // key present ?                    // more elements than expected -> concurrent modification from other thread                    if (ti >= size) {                        throw new ConcurrentModificationException();                    }                    a[ti++] = (T) tab[si+1]; // copy value                }            }            // fewer elements than expected or concurrent modification from other thread detected            if (ti < size || expectedModCount != modCount) {                throw new ConcurrentModificationException();            }            // final null marker as per spec            if (ti < a.length) {                a[ti] = null;            }            return a;        }        public Spliterator<V> spliterator() {            return new ValueSpliterator<>(IdentityHashMap.this, 0, -1, 0, 0);        }    }    /**     * Returns a {@link Set} view of the mappings contained in this map.     * Each element in the returned set is a reference-equality-based     * <tt>Map.Entry</tt>.  The set is backed by the map, so changes     * to the map are reflected in the set, and vice-versa.  If the     * map is modified while an iteration over the set is in progress,     * the results of the iteration are undefined.  The set supports     * element removal, which removes the corresponding mapping from     * the map, via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,     * <tt>removeAll</tt>, <tt>retainAll</tt> and <tt>clear</tt>     * methods.  It does not support the <tt>add</tt> or     * <tt>addAll</tt> methods.     *     * <p>Like the backing map, the <tt>Map.Entry</tt> objects in the set     * returned by this method define key and value equality as     * reference-equality rather than object-equality.  This affects the     * behavior of the <tt>equals</tt> and <tt>hashCode</tt> methods of these     * <tt>Map.Entry</tt> objects.  A reference-equality based <tt>Map.Entry     * e</tt> is equal to an object <tt>o</tt> if and only if <tt>o</tt> is a     * <tt>Map.Entry</tt> and <tt>e.getKey()==o.getKey() &&     * e.getValue()==o.getValue()</tt>.  To accommodate these equals     * semantics, the <tt>hashCode</tt> method returns     * <tt>System.identityHashCode(e.getKey()) ^     * System.identityHashCode(e.getValue())</tt>.     *     * <p><b>Owing to the reference-equality-based semantics of the     * <tt>Map.Entry</tt> instances in the set returned by this method,     * it is possible that the symmetry and transitivity requirements of     * the {@link Object#equals(Object)} contract may be violated if any of     * the entries in the set is compared to a normal map entry, or if     * the set returned by this method is compared to a set of normal map     * entries (such as would be returned by a call to this method on a normal     * map).  However, the <tt>Object.equals</tt> contract is guaranteed to     * hold among identity-based map entries, and among sets of such entries.     * </b>     *     * @return a set view of the identity-mappings contained in this map     */    //键值对的Set    public Set<Map.Entry<K,V>> entrySet() {        Set<Map.Entry<K,V>> es = entrySet;        if (es != null)            return es;        else            return entrySet = new EntrySet();    }    //键值对实体的类    private class EntrySet extends AbstractSet<Map.Entry<K,V>> {        public Iterator<Map.Entry<K,V>> iterator() {            return new EntryIterator();        }        public boolean contains(Object o) {            if (!(o instanceof Map.Entry))                return false;            Map.Entry<?,?> entry = (Map.Entry<?,?>)o;            return containsMapping(entry.getKey(), entry.getValue());        }        public boolean remove(Object o) {            if (!(o instanceof Map.Entry))                return false;            Map.Entry<?,?> entry = (Map.Entry<?,?>)o;            return removeMapping(entry.getKey(), entry.getValue());        }        public int size() {            return size;        }        public void clear() {            IdentityHashMap.this.clear();        }        /*         * Must revert from AbstractSet's impl to AbstractCollection's, as         * the former contains an optimization that results in incorrect         * behavior when c is a smaller "normal" (non-identity-based) Set.         */        public boolean removeAll(Collection<?> c) {            Objects.requireNonNull(c);            boolean modified = false;            for (Iterator<Map.Entry<K,V>> i = iterator(); i.hasNext(); ) {                if (c.contains(i.next())) {                    i.remove();                    modified = true;                }            }            return modified;        }        public Object[] toArray() {            return toArray(new Object[0]);        }        @SuppressWarnings("unchecked")        public <T> T[] toArray(T[] a) {            int expectedModCount = modCount;            int size = size();            if (a.length < size)                a = (T[]) Array.newInstance(a.getClass().getComponentType(), size);            Object[] tab = table;            int ti = 0;            for (int si = 0; si < tab.length; si += 2) {                //设置key和value                Object key;                if ((key = tab[si]) != null) { // key present ?                    // more elements than expected -> concurrent modification from other thread                    if (ti >= size) {                        throw new ConcurrentModificationException();                    }                    a[ti++] = (T) new AbstractMap.SimpleEntry<>(unmaskNull(key), tab[si + 1]);                }            }            // fewer elements than expected or concurrent modification from other thread detected            if (ti < size || expectedModCount != modCount) {                throw new ConcurrentModificationException();            }            // final null marker as per spec            if (ti < a.length) {                a[ti] = null;            }            return a;        }        public Spliterator<Map.Entry<K,V>> spliterator() {            return new EntrySpliterator<>(IdentityHashMap.this, 0, -1, 0, 0);        }    }    private static final long serialVersionUID = 8188218128353913216L;    /**     * Save the state of the <tt>IdentityHashMap</tt> instance to a stream     * (i.e., serialize it).     *     * @serialData The <i>size</i> of the HashMap (the number of key-value     *          mappings) (<tt>int</tt>), followed by the key (Object) and     *          value (Object) for each key-value mapping represented by the     *          IdentityHashMap.  The key-value mappings are emitted in no     *          particular order.     */    //序列化的writeObject    private void writeObject(java.io.ObjectOutputStream s)        throws java.io.IOException  {        // Write out and any hidden stuff        s.defaultWriteObject();        // Write out size (number of Mappings)        //先写size        s.writeInt(size);        // Write out keys and values (alternating)        //再接每个key和value        Object[] tab = table;        for (int i = 0; i < tab.length; i += 2) {            Object key = tab[i];            if (key != null) {                s.writeObject(unmaskNull(key));                s.writeObject(tab[i + 1]);            }        }    }    /**     * Reconstitute the <tt>IdentityHashMap</tt> instance from a stream (i.e.,     * deserialize it).     */    private void readObject(java.io.ObjectInputStream s)        throws java.io.IOException, ClassNotFoundException  {        // Read in any hidden stuff        s.defaultReadObject();        // Read in size (number of Mappings)        //读取容量        int size = s.readInt();        // Allow for 33% growth (i.e., capacity is >= 2* size()).        //初始化map        init(capacity((size*4)/3));        // Read the keys and values, and put the mappings in the table        for (int i=0; i<size; i++) {            @SuppressWarnings("unchecked")                K key = (K) s.readObject();            @SuppressWarnings("unchecked")                V value = (V) s.readObject();            putForCreate(key, value);        }    }    /**     * The put method for readObject.  It does not resize the table,     * update modCount, etc.     */    //序列化readObject时，初始化时初始每个键值对    private void putForCreate(K key, V value)        throws IOException    {        Object k = maskNull(key);        Object[] tab = table;        int len = tab.length;        int i = hash(k, len);        Object item;        while ( (item = tab[i]) != null) {            if (item == k)                throw new java.io.StreamCorruptedException();            i = nextKeyIndex(i, len);        }        tab[i] = k;        tab[i + 1] = value;    }    //遍历每个键值对    @SuppressWarnings("unchecked")    @Override    public void forEach(BiConsumer<? super K, ? super V> action) {        Objects.requireNonNull(action);        int expectedModCount = modCount;        Object[] t = table;        for (int index = 0; index < t.length; index += 2) {            Object k = t[index];            if (k != null) {                //将每个键值对的key和value都传到action                action.accept((K) unmaskNull(k), (V) t[index + 1]);            }            if (modCount != expectedModCount) {                throw new ConcurrentModificationException();            }        }    }    //通过函数计算后替换value    @SuppressWarnings("unchecked")    @Override    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {        Objects.requireNonNull(function);        int expectedModCount = modCount;        Object[] t = table;        for (int index = 0; index < t.length; index += 2) {            Object k = t[index];            if (k != null) {                //调用新的函数计算后设置为新的value                t[index + 1] = function.apply((K) unmaskNull(k), (V) t[index + 1]);            }            if (modCount != expectedModCount) {                throw new ConcurrentModificationException();            }        }    }    /**     * Similar form as array-based Spliterators, but skips blank elements,     * and guestimates size as decreasing by half per split.     */    static class IdentityHashMapSpliterator<K,V> {        final IdentityHashMap<K,V> map;        //下标        int index;             // current index, modified on advance/split        int fence;             // -1 until first use; then one past last index        //估计值        int est;               // size estimate        int expectedModCount;  // initialized when fence set        IdentityHashMapSpliterator(IdentityHashMap<K,V> map, int origin,                                   int fence, int est, int expectedModCount) {            this.map = map;            this.index = origin;            this.fence = fence;            this.est = est;            this.expectedModCount = expectedModCount;        }        final int getFence() { // initialize fence and size on first use            int hi;            if ((hi = fence) < 0) {                //初始化                est = map.size;                expectedModCount = map.modCount;                hi = fence = map.table.length;            }            return hi;        }        public final long estimateSize() {            getFence(); // force init            return (long) est;        }    }    static final class KeySpliterator<K,V>        extends IdentityHashMapSpliterator<K,V>        implements Spliterator<K> {        KeySpliterator(IdentityHashMap<K,V> map, int origin, int fence, int est,                       int expectedModCount) {            super(map, origin, fence, est, expectedModCount);        }        public KeySpliterator<K,V> trySplit() {            //分割长2半            int hi = getFence(), lo = index, mid = ((lo + hi) >>> 1) & ~1;            return (lo >= mid) ? null :                new KeySpliterator<K,V>(map, lo, index = mid, est >>>= 1,                                        expectedModCount);        }        @SuppressWarnings("unchecked")        public void forEachRemaining(Consumer<? super K> action) {            if (action == null)                throw new NullPointerException();            int i, hi, mc; Object key;            IdentityHashMap<K,V> m; Object[] a;            if ((m = map) != null && (a = m.table) != null &&                (i = index) >= 0 && (index = hi = getFence()) <= a.length) {                for (; i < hi; i += 2) {                    if ((key = a[i]) != null)                        //将剩余的key传到action                        action.accept((K)unmaskNull(key));                }                if (m.modCount == expectedModCount)                    return;            }            throw new ConcurrentModificationException();        }        //获取第一个非null的key        @SuppressWarnings("unchecked")        public boolean tryAdvance(Consumer<? super K> action) {            if (action == null)                throw new NullPointerException();            Object[] a = map.table;            int hi = getFence();            while (index < hi) {                Object key = a[index];                index += 2;                if (key != null) {                    action.accept((K)unmaskNull(key));                    if (map.modCount != expectedModCount)                        throw new ConcurrentModificationException();                    return true;                }            }            return false;        }        public int characteristics() {            return (fence < 0 || est == map.size ? SIZED : 0) | Spliterator.DISTINCT;        }    }    static final class ValueSpliterator<K,V>        extends IdentityHashMapSpliterator<K,V>        implements Spliterator<V> {        ValueSpliterator(IdentityHashMap<K,V> m, int origin, int fence, int est,                         int expectedModCount) {            super(m, origin, fence, est, expectedModCount);        }        public ValueSpliterator<K,V> trySplit() {            int hi = getFence(), lo = index, mid = ((lo + hi) >>> 1) & ~1;            return (lo >= mid) ? null :                new ValueSpliterator<K,V>(map, lo, index = mid, est >>>= 1,                                          expectedModCount);        }        public void forEachRemaining(Consumer<? super V> action) {            if (action == null)                throw new NullPointerException();            int i, hi, mc;            IdentityHashMap<K,V> m; Object[] a;            if ((m = map) != null && (a = m.table) != null &&                (i = index) >= 0 && (index = hi = getFence()) <= a.length) {                for (; i < hi; i += 2) {                    if (a[i] != null) {                        @SuppressWarnings("unchecked") V v = (V)a[i+1];                        action.accept(v);                    }                }                if (m.modCount == expectedModCount)                    return;            }            throw new ConcurrentModificationException();        }        public boolean tryAdvance(Consumer<? super V> action) {            if (action == null)                throw new NullPointerException();            Object[] a = map.table;            int hi = getFence();            while (index < hi) {                Object key = a[index];                @SuppressWarnings("unchecked") V v = (V)a[index+1];                index += 2;                if (key != null) {                    action.accept(v);                    if (map.modCount != expectedModCount)                        throw new ConcurrentModificationException();                    return true;                }            }            return false;        }        public int characteristics() {            return (fence < 0 || est == map.size ? SIZED : 0);        }    }    static final class EntrySpliterator<K,V>        extends IdentityHashMapSpliterator<K,V>        implements Spliterator<Map.Entry<K,V>> {        EntrySpliterator(IdentityHashMap<K,V> m, int origin, int fence, int est,                         int expectedModCount) {            super(m, origin, fence, est, expectedModCount);        }        public EntrySpliterator<K,V> trySplit() {            int hi = getFence(), lo = index, mid = ((lo + hi) >>> 1) & ~1;            return (lo >= mid) ? null :                new EntrySpliterator<K,V>(map, lo, index = mid, est >>>= 1,                                          expectedModCount);        }        public void forEachRemaining(Consumer<? super Map.Entry<K, V>> action) {            if (action == null)                throw new NullPointerException();            int i, hi, mc;            IdentityHashMap<K,V> m; Object[] a;            if ((m = map) != null && (a = m.table) != null &&                (i = index) >= 0 && (index = hi = getFence()) <= a.length) {                for (; i < hi; i += 2) {                    Object key = a[i];                    if (key != null) {                        @SuppressWarnings("unchecked") K k =                            (K)unmaskNull(key);                        @SuppressWarnings("unchecked") V v = (V)a[i+1];                        action.accept                            (new AbstractMap.SimpleImmutableEntry<K,V>(k, v));                    }                }                if (m.modCount == expectedModCount)                    return;            }            throw new ConcurrentModificationException();        }        public boolean tryAdvance(Consumer<? super Map.Entry<K,V>> action) {            if (action == null)                throw new NullPointerException();            Object[] a = map.table;            int hi = getFence();            while (index < hi) {                Object key = a[index];                @SuppressWarnings("unchecked") V v = (V)a[index+1];                index += 2;                if (key != null) {                    @SuppressWarnings("unchecked") K k =                        (K)unmaskNull(key);                    action.accept                        (new AbstractMap.SimpleImmutableEntry<K,V>(k, v));                    if (map.modCount != expectedModCount)                        throw new ConcurrentModificationException();                    return true;                }            }            return false;        }        public int characteristics() {            return (fence < 0 || est == map.size ? SIZED : 0) | Spliterator.DISTINCT;        }    }}