如果有一个实体类重写了hashCode方法，并且hashCode返回一个固定值，而且需要使用这个实体最为键，我们该怎么办呢？HashMap铁定是没法使用了，因为HashMap使用键hashCode高低位混合对数组长度取余定位位置，使用HashMap的结果就是无论put多少个该实体对象，实际只存了一个键值对。其实JDK中提供了一个Map专门来解决类似这样的问题，对就是IdentityHashMap，再看IdentityHashMap源码时先要搞清楚，它的key和value是在同一个数组里面的，table[i]存放key那么table[i+1]存放key对应的值。
public class IdentityHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, java.io.Serializable, Cloneable
和HashMap一样继承AbstractMap（再次确认Map家族中只有HashTable是叛徒就它不继承AbstractMap）
// 默认长度
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;
// 修改次数
transient int modCount;
// null键
static final Object NULL_KEY = new Object();
public IdentityHashMap() {
init(DEFAULT_CAPACITY);
}
public IdentityHashMap(int expectedMaxSize) {
// 长度小于0时抛异常
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);
}
构造函数委托给init方法初始化
private void init(int initCapacity) {
table = new Object[2 * initCapacity];
}
初始化长度是原来的二倍（直接*2这是什么姿势？涨见识了）
private static int capacity(int expectedMaxSize) {
return
(expectedMaxSize > MAXIMUM_CAPACITY / 3) ? MAXIMUM_CAPACITY :
(expectedMaxSize <= 2 * MINIMUM_CAPACITY / 3) ? MINIMUM_CAPACITY :
Integer.highestOneBit(expectedMaxSize + (expectedMaxSize << 1));
}
看起来有点绕，expectedMaxSize > MAXIMUM_CAPACITY / 3 如果expectedMaxSize大于默认最大值的三分之一，就取默认最大值，否则走后面逻辑
expectedMaxSize <= 2 * MINIMUM_CAPACITY / 3 如果expectedMaxSize小于等于42/3（2）就取默认最小值，否则取Integer.highestOneBit(expectedMaxSize + (expectedMaxSize << 1))，解读expectedMaxSize + (expectedMaxSize << 1) 实际上就是expectedMaxSize的3倍，Integer.highestOneBit 这个函数的作用是取二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果，出最高位以外其他位都是0，代表着个数一定是2的n次幂。大家有没有发现，无参构造函数数组长度为322，带参构造函数长度为MAXIMUM_CAPACITY 、3倍原长取高位或者MINIMUM_CAPACITY ，它的长度依然是2的n次幂。
看过前面HashMap篇后我们已经很强大了[捂脸]，所以这里不再一个方法一个方法解析，只挑几个重要方法讲。。。
public int hashCode() {
int result = 0;
Object[] tab = table;
// 遍历数组（i+2 一定都是key）
for (int i = 0; i < tab.length; i +=2) {
Object key = tab[i];
if (key != null) {
Object k = unmaskNull(key);
// 所有键tab[i]和值tab[i + 1] identityHashCode取异或
result += System.identityHashCode(k) ^
System.identityHashCode(tab[i + 1]);
}
}
// 返回合计值
return result;
}
hashCode方法是将所有键值取异或后累计相加
public boolean equals(Object o) {
// 内存地址一样
if (o == this) {
return true;
} else if (o instanceof IdentityHashMap) {
// 都是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
}
}
private static int hash(Object x, int length) {
// 使用System.identityHashCode(x)计算hash值
int h = System.identityHashCode(x);
// & (length - 1) 都不陌生，取余过程，不知道的看HashMap中推导
return ((h << 1) - (h << 8)) & (length - 1);
}
有个疑问(h << 1) - (h << 8)为什么不会是负的？探索中
private static int nextKeyIndex(int i, int len) {
return (i + 2 < len ? i + 2 : 0);
}
当前位置加2，就是下一个可以所在位置，加1是当前键对应的值
public V put(K key, V value) {
// null的key转成Object(NULL_KEY)
final Object k = maskNull(key);
// retryAfterResize: 是java中标签用法
retryAfterResize: for (;;) {
final Object[] tab = table;
final int len = tab.length;
// 同样先计算数组下标位置
int i = hash(k, len);
// 先在数组里找是否有相同的key，找到则替换
for (Object item; (item = tab[i]) != null;
i = nextKeyIndex(i, len)) {
if (item == k) {
@SuppressWarnings("unchecked")
V oldValue = (V) tab[i + 1];
tab[i + 1] = value;
return oldValue;
}
}
// 没有找到则执行插入，先存放的键值对数量+1
final int s = size + 1;
// 如果元素个数*3大于数组长度，则进行扩容，扩容后的大小为原长度两倍
if (s + (s << 1) > len && resize(len))
continue retryAfterResize;
// 修改次数加1
modCount++;
// tab[i]存键，tab[i+1]存值
tab[i] = k;
tab[i + 1] = value;
size = s;
return null;
}
}
private boolean resize(int newCapacity) {
// 新的length是原来的两倍
int newLength = newCapacity * 2;
Object[] oldTable = table;
int oldLength = oldTable.length;
// 如果已经到了最大的容量，则扩容失败
if (oldLength == 2 * MAXIMUM_CAPACITY) {
// 如果已经到了最大的容量，(留一个给null，不然不能退出循环)
if (size == MAXIMUM_CAPACITY - 1)
throw new IllegalStateException("Capacity exhausted.");
return false;
}
if (oldLength >= newLength)
return false;
//下面就是循环旧的table，然后插入值到新的里面
Object[] newTable = new Object[newLength];
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;
return true;
}
public V get(Object key) {
Object k = maskNull(key);
Object[] tab = table;
int len = tab.length;
int i = hash(k, len);
// 死循环遍历table数组
while (true) {
Object item = tab[i];
// 如果命中相同的key，就返回table[i+1]的值
if (item == k)
return (V) tab[i + 1];
// 如果遍历完数组还未命中，就返回空
if (item == null)
return null;
i = nextKeyIndex(i, len);
}
}
public V remove(Object key) {
Object k = maskNull(key);
Object[] tab = table;
int len = tab.length;
// 确定位置
int i = hash(k, len);
while (true) {
// 获取key
Object item = tab[i];
if (item == k) {
modCount++;
size--;
// 获取原值
V oldValue = (V) tab[i + 1];
// 清空原值所在位置
tab[i + 1] = null;
// 清空键所在位置
tab[i] = null;
closeDeletion(i);
// 返回原值
return oldValue;
}
if (item == null)
return null;
// 没找到索引加2
i = nextKeyIndex(i, len);
}
}
public void clear() {
modCount++;
Object[] tab = table;
// 这里清空tab每一个元素相当于key和value都将被清空
for (int i = 0; i < tab.length; i++)
tab[i] = null;
size = 0;
}
原文：https://www.cnblogs.com/yuanjiangnan/p/12633965.html