import java.util.Map;
import java.util.HashMap;
import java.util.IdentityHashMap;public class IdentityHashMapTest {public static void main(String[] args) {Map<String, String> hashMaps = new HashMap<String, String>();Map<String, String> identityMaps = new IdentityHashMap<String, String>();hashMaps.put(new String("aa"), "aa");hashMaps.put(new String("aa"), "bb");identityMaps.put(new String("aa"), "aa");identityMaps.put(new String("aa"), "bb");System.out.println(hashMaps.size() + " : " + hashMaps);System.out.println(identityMaps.size() + " : " + identityMaps);}
}

public class IdentityHashMap<K,V>extends AbstractMap<K,V>implements Map<K,V>, java.io.Serializable, Cloneable
{// 缺省容量大小private static final int DEFAULT_CAPACITY = 32;// 最小容量private static final int MINIMUM_CAPACITY = 4;// 最大容量private static final int MAXIMUM_CAPACITY = 1 << 29;// 用于存储实际元素的表transient Object[] table;// 大小int size;// 对Map进行结构性修改的次数transient int modCount;// null key所对应的值static final Object NULL_KEY = new Object();
}

public IdentityHashMap() {init(DEFAULT_CAPACITY);
}

public IdentityHashMap(int expectedMaxSize) {if (expectedMaxSize < 0)throw new IllegalArgumentException("expectedMaxSize is negative: "+ expectedMaxSize);init(capacity(expectedMaxSize));}

public IdentityHashMap(Map<? extends K, ? extends V> m) {// 调用其他构造函数this((int) ((1 + m.size()) * 1.1));putAll(m);}

// 此函数返回的值是最小大于expectedMaxSize的2次幂private static int capacity(int expectedMaxSize) {// assert expectedMaxSize >= 0;return(expectedMaxSize > MAXIMUM_CAPACITY / 3) ? MAXIMUM_CAPACITY :(expectedMaxSize <= 2 * MINIMUM_CAPACITY / 3) ? MINIMUM_CAPACITY :Integer.highestOneBit(expectedMaxSize + (expectedMaxSize << 1));}

// hash函数，由于length总是为2的n次幂，所以 & (length - 1)相当于对length取模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 hashreturn ((h << 1) - (h << 8)) & (length - 1);}

public V get(Object key) {// 保证null的key会转化为Object(NULL_KEY)Object k = maskNull(key);// 保存tableObject[] tab = table;int len = tab.length;// 得到key的散列位置int i = hash(k, len);// 遍历table，解决散列冲突的办法是若冲突，则往后寻找空闲区域while (true) {Object item = tab[i];// 判断是否相等(地址是否相等)if (item == k)// 地址相等，即完全相等的两个对象return (V) tab[i + 1];// 对应散列位置的元素为空，则返回空if (item == null)return null;// 取下一个Key索引i = nextKeyIndex(i, len);}}

// 下一个Key索引private static int nextKeyIndex(int i, int len) {// 往后移两个单位return (i + 2 < len ? i + 2 : 0);}

public V put(K key, V value) {// 保证null的key会转化为Object(NULL_KEY)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)) {if (item == k) { // 经过hash计算的项与key相等@SuppressWarnings("unchecked")// 取得值V oldValue = (V) tab[i + 1];// 将value存入tab[i + 1] = value;// 返回旧值return oldValue;}}// 大小加1final int s = size + 1;// Use optimized form of 3 * s.// Next capacity is len, 2 * current capacity.// 如果3 * size大于length，则会进行扩容操作if (s + (s << 1) > len && resize(len))// 扩容后重新计算元素的值，寻找合适的位置进行存放continue retryAfterResize;// 结构性修改加1modCount++;// 存放key与valuetab[i] = k;tab[i + 1] = value;// 更新sizesize = s;return null;}}

private boolean resize(int newCapacity) {// assert (newCapacity & -newCapacity) == newCapacity; // power of 2int newLength = newCapacity * 2;// 保存原来的tableObject[] oldTable = table;int oldLength = oldTable.length;// 旧表是否为最大容量的2倍if (oldLength == 2 * MAXIMUM_CAPACITY) { // can't expand any further// 之前元素个数为最大容量，抛出异常if (size == MAXIMUM_CAPACITY - 1)throw new IllegalStateException("Capacity exhausted.");return false;}// 旧表长度大于新表长度，返回falseif (oldLength >= newLength)return false;// 生成新表Object[] newTable = new Object[newLength];// 将旧表中的所有元素重新hash到新表中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;}}// 新表赋值给tabletable = newTable;return true;}

public V remove(Object key) {// 保证null的key会转化为Object(NULL_KEY)Object k = maskNull(key);Object[] tab = table;int len = tab.length;// 计算hash值int i = hash(k, len);while (true) {Object item = tab[i];// 找到key相等的项if (item == k) {modCount++;size--;@SuppressWarnings("unchecked")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);}}

private void closeDeletion(int d) {// Adapted from Knuth Section 6.4 Algorithm RObject[] 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;}}}