JDK之IdentityHashMap源码解析

刚入java不久的程序猿，对于简单的使用已毫不满足，最终为了一探究竟，翻开了JDK的源码，以下观点为自己的理解及看了多篇博客的总结，欢迎各位大神指出不对的地方，当然也欢迎和我一样刚学的同学，一起加油努力吧~~

IdentityHashMap是什么

IdentityHashMap与HashMap一样，也是一个通过键值对来存储元素的集合，但是IdentityHashMap相对于HashMap不同的是，它能够存储key值相同的元素，并且存储方式上，数据都存储在map中，没有使用链表

IdentityHashMap源码解析

IdentityHashMap和HashMap结构相同都是继承AbstractMap，实现Map接口

public class IdentityHashMap<K,V>    extends AbstractMap<K,V>    implements Map<K,V>, java.io.Serializable, Cloneable{...}

因为与HashMap一样，这里就不做说明了，具体的可以看HashMap源码解析，下面我们直接来看IdentityHashMap的源码

    /**     * 默认容量     */    private static final int DEFAULT_CAPACITY = 32;    /**     * 最小容量     */    private static final int MINIMUM_CAPACITY = 4;    /**     * 最大容量     */    private static final int MAXIMUM_CAPACITY = 1 << 29;    /**     * 存放元素的数组     */    private transient Object[] table;    /**     * 元素的数量     */    private int size;    /**     * 修改次数     */    private transient int modCount;    /**     * 阈值(容量*加载因子)     */    private transient int threshold;    /**     * 常量NULL_KEY     */    private static final Object NULL_KEY = new Object();

了解了变量后，我们来看下IdentityHashMap的构造方法

    /**     * 无参构造，调用init方法，后面有详细说明     */    public IdentityHashMap() {        init(DEFAULT_CAPACITY);    }    /**     * 构造方法，参数为期望最大容量大小     */    public IdentityHashMap(int expectedMaxSize) {        if (expectedMaxSize < 0)            throw new IllegalArgumentException("expectedMaxSize is negative: "                                               + expectedMaxSize);        init(capacity(expectedMaxSize));    }    /**     * 构造方法，参数为map     */    public IdentityHashMap(Map<? extends K, ? extends V> m) {        // 调用构造方法        this((int) ((1 + m.size()) * 1.1));        putAll(m);    }    /**     * 通过expectedMaxSize计算容量     */    private int capacity(int expectedMaxSize) {        // 计算最小容量，大小为expectedMaxSize的1.5倍        int minCapacity = (3 * expectedMaxSize)/2;        // 实际的大小        int result;        // 当最小容量大于最大容量或者小于0时，将最大容量赋予result        if (minCapacity > MAXIMUM_CAPACITY || minCapacity < 0) {            result = MAXIMUM_CAPACITY;        } else {            // 将最小容量赋予result            result = MINIMUM_CAPACITY;            // 当result小于计算出的最小容量时，将result扩大一倍            while (result < minCapacity)                result <<= 1;        }        return result;    }    /**     * 初始化方法，initCapacity在最小与最大值之间     */    private void init(int initCapacity) {        //阈值，大小为初始化容量的三分之二        threshold = (initCapacity * 2)/3;        //表的容量为2倍的初始化容量大小        table = new Object[2 * initCapacity];    }

看完上述代码，我们发现init方法最为重要，阈值为什么要乘以三分之二？其实这个三分之二就是加载因子，初始化容量乘以加载因子算出阈值，表的容量为2倍，这是由于key，value都存于表中，而未使用链表，接下来我们继续看代码

    /**     * IdentityHashMap存入键值对的方法     */    public V put(K key, V value) {        //判断参数是否为空，返回NULL_KEY或者key        Object k = maskNull(key);        Object[] tab = table;        //数组的长度        int len = tab.length;        //根据key值和数组长度计算下标        int i = hash(k, len);        Object item;        //循环数组，元素非空时进入        while ( (item = tab[i]) != null) {            //当key与元素相等时，设置value，并取出旧的value            if (item == k) {                V oldValue = (V) tab[i + 1];                tab[i + 1] = value;                return oldValue;            }            //下一个key的下标            i = nextKeyIndex(i, len);        }        //修改次数+1        modCount++;        //无此元素时，下标i处放入key，i+1处放入value        tab[i] = k;        tab[i + 1] = value;        //当元素的长度大于阈值时候扩容        if (++size >= threshold)            //扩容方法            resize(len); // len == 2 * current capacity.        return null;    }    /**     * IdentityHashMap的get方法     */    public V get(Object key) {        //判断参数是否为空，返回NULL_KEY或者key        Object k = maskNull(key);        Object[] tab = table;        //数组的长度        int len = tab.length;        //根据key值和数组长度计算下标        int i = hash(k, len);        //循环数组，当key值与数组中一致时，取出value        while (true) {            Object item = tab[i];            if (item == k)                return (V) tab[i + 1];            if (item == null)                return null;            i = nextKeyIndex(i, len);        }    }    /**     * 判断参数是否为空，为空返回NULL_KEY，否则返回key     */    private static Object maskNull(Object key) {        return (key == null ? NULL_KEY : key);    }    /**     * 根据key值和数组长度，计算数组中的下标     */    private static int hash(Object x, int length) {        int h = System.identityHashCode(x);        //前半部分没怎么懂，后半部分是取余，至于为什么不用%length，好像是在性能方面这样更好        return ((h << 1) - (h << 8)) & (length - 1);    }    /**     * 下一个key的下标，由于下一位是value，所以这里的key为i+2     */    private static int nextKeyIndex(int i, int len) {        return (i + 2 < len ? i + 2 : 0);    }    /**     * 扩容方法     */    private void resize(int newCapacity) {        // 扩容长度为原先长度的两倍        int newLength = newCapacity * 2;        Object[] oldTable = table;        //原先数组的长度        int oldLength = oldTable.length;        if (oldLength == 2*MAXIMUM_CAPACITY) { // can't expand any further            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 = newLength / 3;        //循环旧的table，将key，value放入新的数组        for (int j = 0; j < oldLength; j += 2) {            Object key = oldTable[j];            if (key != null) {                Object value = oldTable[j+1];                oldTable[j] = null;                oldTable[j+1] = null;                int i = hash(key, newLength);                while (newTable[i] != null)                    i = nextKeyIndex(i, newLength);                newTable[i] = key;                newTable[i + 1] = value;            }        }        table = newTable;    }

到这里，比较重要的两个方法我们就看完了，这里我们要注意的是key值后面对应的就是value，没有链表，数据都是存在table中的，细心的小伙伴可能已经发现，get方法里，取值时是引用的相同，这也就说明了为什么可以存入相同值的key，好了，下面简要的说明下剩下的方法，都比较简单

    /**     * 返回元素个数，也就是键值对数量     */    public int size() {        return size;    }    /**     * 判断是否为空     */    public boolean isEmpty() {        return size == 0;    }    /**     * 判断是否包含此key     */    public boolean containsKey(Object key) {        Object k = maskNull(key);        Object[] tab = table;        int len = tab.length;        int i = hash(k, len);        //循环时，找到返回true，没找到返回false        while (true) {            Object item = tab[i];            if (item == k)                return true;            if (item == null)                return false;            i = nextKeyIndex(i, len);        }    }    /**     * 判断是否包含此value     */    public boolean containsValue(Object value) {        Object[] tab = table;        //循环数组里的value，找到返回true，没找到返回false        for (int i = 1; i < tab.length; i += 2)            if (tab[i] == value && tab[i - 1] != null)                return true;        return false;    }    /**     * 判断是否包含键值对     */    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);        }    }    /**     * 将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));        for (Entry<? extends K, ? extends V> e : m.entrySet())            put(e.getKey(), e.getValue());    }    /**     * 根据key值移除键值对，返回该key对应的旧的value     */    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++;                //长度-1                size--;                V oldValue = (V) tab[i + 1];                //置空                tab[i + 1] = null;                tab[i] = null;                closeDeletion(i);                return oldValue;            }            if (item == null)                return null;            i = nextKeyIndex(i, len);        }    }    /**     * 根据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);        }    }    /**     * 删除后调用     */    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;            }        }    }    /**     * 清空     */    public void clear() {        modCount++;        Object[] tab = table;        for (int i = 0; i < tab.length; i++)            tab[i] = null;        size = 0;    }    /**     * 比较     */    public boolean equals(Object o) {        if (o == this) {            return true;        } else if (o instanceof IdentityHashMap) {            IdentityHashMap m = (IdentityHashMap) o;            if (m.size() != size)                return false;            Object[] tab = m.table;            for (int i = 0; i < tab.length; i+=2) {                Object k = tab[i];                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        }    }

好了，到这里IdentityHashMap就看完了，感兴趣的同学可以打开源码里面还有一些内部类，迭代的东西，可以看一看，好了，就说到这里了~