JDK7的HashMap
JDK7的HashMap是通过数组+链表实现的
HashMap的成员变量
int DEFAULT_INITIAL_CAPACITY = 16： 默认的初始容量为16
int MAXIMUM_CAPACITY = 1 << 30： 最大的容量为 2 ^ 30
float DEFAULT_LOAD_FACTOR = 0.75f： 默认的加载因子为 0.75f
Entry< K,V>[] table： Entry类型的数组，HashMap用这个来维护内部的数据结构，它的长度由容量决定
int size： HashMap的大小
int threshold： HashMap的极限容量，扩容临界点（容量和加载因子的乘积）
构造方法
//无参构造器
public HashMap() {
//默认初始容量大小为16,默认的加载因子为0.75f
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
//初始容量不能小于0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//初始容量不能超过1073741824
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//加载因子不能小于等于0,或者加载因子不能是非数字
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//设置加载因子
this.loadFactor = loadFactor;
//设置临界值
threshold = initialCapacity;
//伪构造,里面没有代码，在LinkedHashMap里才有实现
init();
}
put方法
public V put(K key, V value) {
//先判断哈希表是否为空,第一次put的话肯定是为空的，
if (table == EMPTY_TABLE) {
// roundUpToPowerOf2方法的作用是将构造器传入的容量初始化大小
//转成最接近2的n字方值,为什么要2的n字方,下面会提到
int capacity = roundUpToPowerOf2(threshold);
//临界值是加载因子*容量大小
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建一个Entry数组
table = new Entry[capacity];
//initHashSeedAsNeeded方法的作用:找到与该实例的一个哈希掩码值,使哈希碰撞几率更为小.里
//面会生成一个hashSeed，将会在生成哈希值里面可能会用到。
initHashSeedAsNeeded(capacity);
}
//如果key为null
if (key == null)
//这个方法下面讲解
return putForNullKey(value);
//计算key的哈希值
int hash = hash(key);
//计算该哈希值在哈希表的下标
int i = indexFor(hash, table.length);
//如果刚刚计算出来的下标在哈希表里面为空的话，将不会进入循环
//不为空将遍历table[i]的链表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//判断该链表上是否有相同的哈希值和相同的地址值,或者key相同
//若存在则覆盖旧值,返回旧值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
重点是其中的roundUpToPowerOf2方法，作用是能够得到大于且最接近number的2的幂(如:number=10，结果就是16)
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
//将number减1后再左移一位作为参数传给highestOneBit方法
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
而这个方法中用到了highestOneBit方法
public static int highestOneBit(int i) {
// HD, Figure 3-1
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}
该方法通过右移位和或运算得到小于且最接近i的2的幂，但是这个方法得到的结果似乎与想要的不同，
所以，需要将number减1后左移一位((number - 1) << 1)作为参数传给highestOneBit方法，即达到roundUpToPowerOf2方法想要的结果。
为什么数组容量必须是2的幂
取数组坐标的方法如下
static indexFor(int h,int length){
return h & (length - 1);
}
h是key经hash后得到的结果
只有length是2的幂，才能保证 h & (length - 1)的结果小于length，即数组下标小于length
例如，任何数与 0000 1111(15)相与，结果都小于0000 1111(15)
添加新节点
向链表中插入新节点的方式(发生碰撞的情况)
- JDK7添加新节点的方式是前插法，目的是加快插入效率
- JDK8添加新节点的方式是尾插法，因为每次插入都必须要检查链表节点的个数，选择要不要把链表转换为红黑树
JDK7的前插法在多线程环境下扩容时 会造成循环链表，造成死循环
JDK8的尾插法则不会导致这种结果
void addEntry(int hash, K key, V value, int bucketIndex) {
//如果结点个数大于或等于临界值和该哈希表指定的索引位置不为null
if ((size >= threshold) && (null != table[bucketIndex])) {
//扩容会在重点讲解
resize(2 * table.length);
//这一步就是对null的处理，如果key为null，hash值为0，
//也就是会插入到哈希表的表头table[0]的位置
hash = (null != key) ? hash(key) : 0;
//因为扩容了，需要重新计算哈希表的位置
bucketIndex = indexFor(hash, table.length);
}
//创建Entry结点的操作
createEntry(hash, key, value, bucketIndex);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
//查找出指定索引的结点对象，目的：形成一个链表
Entry<K,V> e = table[bucketIndex];
//第一个参数书哈希值，第二个是key值，第三个是value值
//第四个哈希表指定索引结点的对象，这样就形成了一个单链链表了。
//为什么要放在链表头，因为好像作者说后面放进去的结点会更大几率使用到。欢迎纠错。
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
扩容
扩容条件
void addEntry(int hash, K key, V value, int bucketIndex) {
//扩容条件：如果结点个数大于等于临界值且该哈希表指定的索引位置不为null
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
//这一步就是对null的处理，如果key为null，hash值为0，
//也就是会插入到哈希表的表头table[0]的位置
hash = (null != key) ? hash(key) : 0;
//因为扩容了，需要重新计算哈希表的位置
bucketIndex = indexFor(hash, table.length);
}
//创建Entry结点的操作
createEntry(hash, key, value, bucketIndex);
}
扩容
void resize(int newCapacity) {
//引用扩容前的Entry数组
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//如果扩容前的数组大小如果已经达到最大(2^30)了
//修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//创建一个新的哈希表
Entry[] newTable = new Entry[newCapacity];
//将当前所有的哈希表数据复制到新的哈希表
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//计算临界值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//将当前所有的哈希表数据复制到新的哈希表
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
//遍历旧的哈希表
for (Entry<K,V> e : table) {
while(null != e) {
//保存旧的哈希表对应的链表头的下一个结点
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//因为哈希表的长度变了，需要重新计算索引
int i = indexFor(e.hash, newCapacity);
//第一次循环的newTable[i]为空，赋值给当前结点的下一个元素，
//下面有图会讲解这句代码的含义
e.next = newTable[i];
//将结点赋值到新的哈希表
newTable[i] = e;
e = next;
}
}
}
扩容时，几乎不会对key进行重新计算hash值，只需要用原来的hash值与新得到的数组长度length-1相与即可。
例如，原来数组长度是8时，需要将hash值与 111 相与，得到数组下标(存放位置)，
扩容后数组长度变为16，只需要将原来的hash值与 1111 相与，即可得到新的数组下标
get方法
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
//key为null的处理方法
private V getForNullKey() {
if (size == 0) {
return null;
}
//因为key为null添加的时候是放在哈希表索引0的位置的。
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
//找到key为null，则终止循环，返回值
if (e.key == null)
return e.value;
}
return null;
}
//获取值
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
//计算key的哈希值
int hash = (key == null) ? 0 : hash(key);
//table[indexFor(hash, table.length）这个方法的目的是找到对应的链表，开始遍历
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
remove方法
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
//判断是在数组下标处还是在数组的单向链表上
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
//如果走到这一步，则说明该元素在单向链表上
prev = e;
e = next;
}
return e;
}
迭代器
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // 记录索引
Entry<K,V> current; // current entry
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
//找到在数组里第一个元素
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
final Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
//如果在这个索引上没有单向链表的话，
if ((next = e.next) == null) {
Entry[] t = table;
//向下个索引查找不为null的元素
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
}
JDK8的HashMap
JDK8 在 JDK7 数组+链表的基础上增加了红黑树
之所以使用红黑树，是因为红黑树在查找和插入多种情况下综合来说，效率较高
链表 or 红黑树
- 在同一个数组下标之下，如果链表的节点数大于8，该链表就会重构成一棵红黑树
- 如果红黑树的节点小于6，该红黑数就会重构成一个链表
添加新节点的方式
向链表中插入新节点的方式(发生碰撞的情况)
- JDK7添加新节点的方式是前插法，目的是加快插入效率
- JDK8添加新节点的方式是尾插法，因为每次插入都必须要检查链表节点的个数，选择要不要把链表转换为红黑树
JDK7的前插法在多线程环境下扩容时 会造成循环链表，造成死循环
JDK8的尾插法则不会造成这种结果