Java源码阅读之IdentityHashMap

在java中，IdentityHashMap是唯一允许出现相等键的map，因为在IdentityHashMap中判断键相等是判断引用相等，而在其他map中判断键相等是根据值相等来进行判断；

类定义

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

类属性

// 默认的容量大小，当采用装载因子2/3时，map的最大size为21
private static final int DEFAULT_CAPACITY = 32;

// 最小的初始容量
private static final int MINIMUN_CAPACITY = 4;

// 最大的map容量
private static final int MAXIMUM_CAPACITY = 1 << 29;

// 用于存储键值对的数组
transient Object[] table;

// map中的键值对数量
int size;

transient int modCount;

static final Object NULL_KEY = new Object();

构造函数

// 用默认初始容量32，和默认装载因子2/3创建map
public IdentityHashMap(){
	init(DEFAULT_CAPACITY);
}

// 使用期望能够装填的键值对的数量来进行map的创建
// 这里的expectedMaxSize就相当于HashMap中的threshold
// IdentityHashMap的默认装载因子为2/3
public IdentityHashMap(int expectedMaxSize){
	if(expectedMaxSize < 0){
		throw new IllegalArgumentException("expectedMaxSize is negative : " + expectedMaxSize);
	}
	// 用能满足expecedMaxSize的最小容量初始化map，容量必须为2的幂次
	init(capacity(expectedMaxSize));
}

public IdentityHashMap(Map<? extends K, ? extends V> m){
	this((int)((1 + m.size()) * 1.1));
	putAll(m);
}

方法

// 使用期望的能存储的最大数量的键值对数，和默认的装载因子2/3计算出能满足的最小的2的幂次的容量
private static int capacity(int expectedMaxSize){
	return (exceptedMaxSize > MAXIMUM_CAPACITY/3 ? MAXIMUN_CAPACITY:
			(exceptedMaxSize <= 2 * MINIMUM_CAPACITY/3) ? MINIMUM_CAPACITY :
			Integer.highestOneBit(expectedMaxSize + (expectedMaxSize << 1)));
}

// 对identityHashmap进行初始化
private void init(int initCapacity){
	table = new Object[initCapacity * 2];
}

// 返回指定键的索引位置
private static int hash(Object x, int length){
	int h = System.identityHashCode(x);
	return ((h << 1) - (h << 8)) & (length - 1);
}

// 查找下一个key的索引，IdentityHashMap采用的线性探测法解决冲突
private static int nextKeyIndex(int i, int len){
	return (i + 2 < len ? i + 2 : 0);
}

// 向map中插入元素
public V put(Objcet key, Object value){
	final Object k = maskNull(key);

	retryAfterResize:for(;;){
		final Object[] tab = table;
		final int len = tab.length;
		int i = hash(key, len);
		// 如果键已经存在，则替换旧值
		for(Object item; (item = tab[i]) != null; i = nextKeyIndex(i, len)){
			if(item == k){
				V oldValue = (V) tab[i+1];
				tab[i+1] = value;
				return oldValue;
			}
		}
		final int s = size + 1;
		// 当容量达到阈值，则进行扩容
		if((s + (s << 1)) > len && resize(len)){
			continue retryAfterResize;
		}

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

public V get(Object key){
	Object k = maskUnll(key);
	Object[] tab = table;
	int len = tab.length;
	int i = hash(k, len);
	
	while(true){
		Object item = tab[i];
		if(item == k){
			return (V) tab[i+1];
		}
		if(item == null){
			return null;
		}
		i = nextKeyIndex(i, len);
	}
}

// 查找map中是否有指定的键
public boolean containsKey(Object key){
	Object k = maskUnll(key);
	Object[] tab = table;
	int len = tab.length;
	int i = hash(k, len);
	while(true){
		Object item = tab[i];
		if(item == key){
			return true;
		}
		if(item == null){
			return false;
		}
		i = nextKeyIndex(i, len);
	}
}

// 查找map中是否有指定的值
public boolean containsValue(Object value){
	// 按照存储结构，值只能从索引位置为1的地方开始存储
	// 遍历一遍map查询是否有指定的值存在
	for(int i = 1; i < table.length; i+=2){
		// 查找到指定的值且有对应的键关联
		if(table[i] == value && table[i-1] != null){
			return true;
		}
	}
	return false;
}

// 查找map中是否存在指定的键值对
private boolean containsMapping(Object key, Object value){
	final 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 value == tab[i+1]
		}
		if(item == null){
			return false;
		}
		i = nextKeyIndex(i, len);
	}
}

// 使用新容量对容器进行扩容
public boolean resize(int newCapacity){
	int newLength = 2 * newCapacity;

	Object[] oldTable = table;
	int oldLength = oldTable.length;
	if(oldLength == 2 * MAXIMUM_CAPACITY){
		// 已经达到最大容量，不能再继续扩容了
		if(size == MAXIMUM_CAPACITY - 1){
			// 内存耗尽
			throw new IllegalStateException("Capacity exhausted.");
		}
		return false;
	}
	if(oldLength >= newLength){
		return false;
	}
	Object[] newTable = new Object[newLength];
	for(int i = 0; i < oldLength; i += 2){
		Object key = oldTable[i];
		if(key != null){
			Objcet value = oldTable[i + 1];
			oldTable[i] = null;
			oldTable[i + 1] = null;
			int j = hash(key, newLength);
			while(newTable[j] != null)
				j = nextKeyIndex(j, newLength);
			newTable[j] = key;
			newTable[j + 1] = value;
		}
	}
	table = newTable;
	return true;
}

// 将给定map中的所有键值对添加到当前map中，如果有重复的键，则用给定的map中的键值对替换当前map中的键值对
public void putAll(Map<? extends K, ? extends V> m){
	int n = m.size();
	if(n == 0){
		return;
	}
	if(n > size){
		resize(capacity(n));
	}
	for(Map.Entry<K,V> entry : m.entrySet()){
		put(entry.getKey(), entry.getValue());
	}
}

// 根据指定的键来删除键值对
// 如果键key存在则删除键值对，并返回关联的值
// 如果键key不存在则返回null
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 --;
			V oldValue = (V) tab[i + 1];
			tab[i] = null;
			tab[i + 1] = null;
			closeDeletion(i);
			return oldValue;
		}
		if(item == null){
			// 没有查找到指定的值
			return null;
		}
		i = nextKeyIndex(i, len);
	}
}

// 删除之后，需要将具有相同hash值的后续键值对向前移动
private void closeDeletion(int d){
	Object[] tab = table;
	int len = tab.length;
	
	Object item;
	for(int i = nextKeyIndex(d, len); (item = tab[i]) != null; i = nextKeyIndex(i, len)){
		// 计算后续键值对的hash值
		int r = hash(item, len);
		if((i < r && (r <= d || d <= i)) || (r <= d && d <= i)){
			tab[d] = tab[i];
			tab[d + 1] = tab[i + 1];
			tab[i] = null;
			tab[i + 1] = null;
			d = i;
		}	
	}
}

// 清空map
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){
			Objcet 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(o.entrySet());
	}else{
		return false;
	}
}

HashCode

public int hashCode(){
	int result = 0;
	Object[] tab = table;
	for(int i = 0; i < tab.length; i ++){
		Object key = tab[i];
		if(key != null){
			Object k = unmaskNull(key);
			result += System.identityHashCode(k) ^ System.identityHashCode(tab[i+1]);
		}
	}
	return result;
}