本文详细探讨了HashMap在Java 1.7版本的实现，包括其继承结构、数据结构（数组+链表）、成员变量、构造方法、put、get、remove等核心操作的源码分析。特别指出，HashMap在1.7版本中使用头插法可能导致并发下的链表死循环问题。
概述
本文主要分析HashMap类的源码
HashMap继承结构
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{
HashMap继承结构图
可以看到：
1、实现了 Map 接口，拥有一组map的通用操作
2、实现了 Cloneable 接口，可进行拷贝，需要注意的是 hashmap 是浅拷贝，修改拷贝对象对源对象会产生影响
3、实现了 Serializable 接口，实现了序列化，可保存于本地
HashMap的数据结构
数组 + 单向链表
HashMap的成员变量
/**
* The default initial capacity - MUST be a power of two.
* 默认初始容量
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
* 最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The load factor used when none specified in constructor.
* 默认负载因子，用来指示元素个数占整体容量的比例，当元素达到这个比例的时候，就准备扩容了
* 为什么加载因子是0.75？【经常被问到的面试题】
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The table, resized as necessary. Length MUST Always be a power of two.
* 用来存储键值对的Entry数组
*/
transient Entry<K,V>[] table;
/**
* The number of key-value mappings contained in this map.
* 实际的元素个数
*/
transient int size;
/**
* The next size value at which to resize (capacity * load factor).
* 阈值 = capacity（容量）* loadFactor（负载因子。这个值是当前已占用数组长度的最大值。size 超过这个值就重新 resize（扩容），
* 扩容后的 HashMap 容量是之前容量的两倍。默认的临界值是12 = 16 * 0.75
*/
int threshold;
/**
* The load factor for the hash table.
* 哈希表的负载因子，默认是0.75f
*/
final float loadFactor;
/**
* 每次扩容和更改 map 结构的计数器
*/
transient int modCount;
Entry必须要介绍一下，看源码
static class Entry<K,V> implements Map.Entry<K,V> {
final K key; // 存储的key
V value; // 存储的value
Entry<K,V> next; // next指针，指向下一个节点
int hash; // 哈希值
可以看到，Entry 是 HashMap 的静态内部类，key 是存储的键，value 是存储的值，由于HashMap的数据结构是数组 + 链表，所以 next 是链表指向下一个节点的指针，hash 是哈希值
HashMap的构造方法
两个参数的构造方法
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
* 两个参数的构造方法
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
public HashMap(int initialCapacity, float loadFactor) {
// 初始容量不合法抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 超过最大容量的话就设置为最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// Find a power of 2 >= initialCapacity
// 传入的容量并不一定是2的n次幂，找到最小的二次幂容量
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
// 实际负载因子
this.loadFactor = loadFactor;
// 阈值
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
// 根据容量创建 table 数组
table = new Entry[capacity];
useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
// 空方法，留给用户自己扩展
init();
}
一个参数的构造方法
// 一个参数的构造方法，使用默认负载因子0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
无参构造函数
public HashMap() {
//传入默认大小，和加载因子
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
put方法
public V put(K key, V value) {
// 如果key为null，单独处理
if (key == null)
return putForNullKey(value);
int hash = hash(key);//计算出哈希值
int i = indexFor(hash, table.length);//通过哈希值计算出哈希桶的位置
//遍历链表,判断是否有key相等(即哈希值相等)的节点,如果有,则更新值,并返回旧的值
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++; // 更新次数+1
addEntry(hash, key, value, i); // 没有找到相同的
return null;
}
putForNullKey()方法
// 如果key为null
private V putForNullKey(V value) {
// key为null的键值对，默认存放在0号位置
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
// 覆盖相同的值
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0); // 没有找到相同的
return null;
}
hash()方法
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
h ^= k.hashCode();
// 通过多次位运算进行扰动，减少哈希冲突
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
indexFor()方法
// 计算Entry在数组中的位置
static int indexFor(int h, int length) {
// 和长度-1进行与运算，相当于进行模n计算
return h & (length-1);
}
addEntry()方法
void addEntry(int hash, K key, V value, int bucketIndex) {
//判断是否要扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length); // 扩容
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
resize()方法
void resize(int newCapacity) {
Entry[] oldTable = table; // 旧的数组
int oldCapacity = oldTable.length; // 旧的容量
if (oldCapacity == MAXIMUM_CAPACITY) { // 如果本身达到了最大的容量
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity]; // 创建新的数组，容量为原来的2倍
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
transfer(newTable, rehash); // 迁移旧的Entry到扩容后的数组中
table = newTable; // 将table指向新的数组
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); // 重新计算阈值
}
createEntry()方法
//头插法在这里
void createEntry(int hash, K key, V value, int bucketIndex) {
//先获取头结点
Entry<K,V> e = table[bucketIndex];
//创建新的节点指向头结点,使其成为新的头结点
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
transfer()方法
/**
* 将所有元素转移到新容器中 newTable。在转移的过程中会产生并发问题，产生 环状，在 get 元素的时候产生死循环
* newCapacity: 容量翻倍的新的空数组
* 双重循环遍历数组+链表
*/
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);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
HashMap1.7的put()方法整体流程如下图：
注意：
HashMap1.7是使用头插法插入节点的，在进行扩容调用resize方法，进而调用transfer方法迁移元素的时候，如果多线程并发，就有可能出现链表死循环的问题。
get()方法
public V get(Object key) {
if (key == null) // key为null单独处理
return getForNullKey();
Entry<K,V> entry = getEntry(key); // 获取元素
return null == entry ? null : entry.getValue();
}
// 如果key为null，就去数组中0位置去查找
private V getForNullKey() {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key); // 计算哈希值
//遍历Entry,判断是否存在相同的key
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
// 如果发现相同的key，就返回value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
get方法先根据hash值计算出在数组中的位置，如果发现相同的key的Entry，就返回值。
remove()方法
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
int hash = (key == null) ? 0 : hash(key);// 计算hash值
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;
}
remove方法通过hash值计算出在数组中桶的位置，然后遍历桶中的Entry，找到相同的key就删除。
扫一扫
1135
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
