前言
从开始学java起就接触了HashMap, 用起来很简单, 存的是键值对, 取的时候根据键取出对应的值. 但是它内部的数据结构是怎么样的, 是怎么实现存取操作, 始终没研究过.
最近在看LruCache, 内部主要用到了LinkedHashMap, LinkedHashMap继承了HashMap, 为了弄懂LruCache的缓存原则, 才看了HashMap的源码, 才有了这篇文章.
注意: 这里分析的是jdk1.7中HashMap, 实现起来比较简单, jdk1.8中对HashMap优化了很多, 变动比较大, 后续文章会涉及到.
HashMap的数据结构
看HasMap的源码会发现有一个数组, 数组中每一个元素都是HashMapEntry:
transient HashMapEntry[] table = (HashMapEntry[]) EMPTY_TABLE;
看下静态内部类HashMapEntry的结构:
static class HashMapEntry implements Map.Entry {
final K key;
V value;
HashMapEntry next;
int hash;
/**
* Creates new entry.
*/
HashMapEntry(int h, K k, V v, HashMapEntry n) {
value = v;
next = n;
key = k;
hash = h;
}
}
保存了key, value, hash, 还有一个next HashMapEntry, 是一个单链表.
So, HashMap的数据结构是数组, 而数组上每一个元素都是一个单链表. (注意: key为空时存储在数组第0位)
代码解析
看代码当然先看构造函数了
static final int DEFAULT_INITIAL_CAPACITY = 4;//默认初始容量, 必须是2的倍数
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY) {
initialCapacity = MAXIMUM_CAPACITY;
} else if (initialCapacity < DEFAULT_INITIAL_CAPACITY) {
initialCapacity = DEFAULT_INITIAL_CAPACITY;//最小容量是4
}
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
threshold = initialCapacity;
init();
}
//需要子类复写, 进行创建之后, 存储数据之前的初始化操作
void init() {
}
然后是我们经常用到的几个方法:
1. put
public V put(K key, V value) {
//如果数组为空, 就去填充数组, threshold为初始容量
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
key为空时, 存储value
if (key == null)
return putForNullKey(value);
//根据key获取到hash值
int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
//根据hash值计算出一个下标
int i = indexFor(hash, table.length);
//遍历该坐标上的链表
for (HashMapEntry e = table[i]; e != null; e = e.next) {
Object k;
//如果找到hash值相等, key也相等的Entry, 替换value, 因此hashmap存数据, key相等时, value会覆盖
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//如果遍历完链表未发现hash值和key相等的entry, 就通过addEntry把key和value存进数组
modCount++;
addEntry(hash, key, value, i);
return null;
}
//数组为空, 初始化数组
private void inflateTable(int toSize) {
// roundUpToPowerOf2返回2的N次方, 根据初始容量获取数组大小
int capacity = roundUpToPowerOf2(toSize);
// 数组大小*加载因子获取到一个临界值, 该临界值在数组扩容时用到, 后面会讲到
float thresholdFloat = capacity * loadFactor;
if (thresholdFloat > MAXIMUM_CAPACITY + 1) {
thresholdFloat = MAXIMUM_CAPACITY + 1;
}
threshold = (int) thresholdFloat;
table = new HashMapEntry[capacity];
}
//key为null时存储数据
private V putForNullKey(V value) {
//遍历数组第0位的链表, 因为key为空的时候, hash为0, 对应下标也是0
for (HashMapEntry e = table[0]; e != null; e = e.next) {
//找到key为null的Entry, 就把value替换成新value
if (e.key == null) {
V oldValue = e.value;
e.value = value;
//记录该entry的值被重写了
e.recordAccess(this);
return oldValue;//返回旧值
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
重点看下addEntry
void addEntry(int hash, K key, V value, int bucketIndex) {
//判断数组大小是否超过临界值, 如果超过临界值且数组当前位置不为空就要对数组扩容
if ((size >= threshold) && (null != table[bucketIndex])) {
//对数组扩容, 容量变为2倍
resize(2 * table.length);
//重新计算key的hash值和对应的下标
hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
//数组中增加Entry
void createEntry(int hash, K key, V value, int bucketIndex) {
//先保存当前位置的Entry
HashMapEntry e = table[bucketIndex];
//新建一个Entry, next指向之前的Entry, 即新建的Entry加入单链表头部
table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
size++;
}
总结一下, 就是根据key找到对应的下标, 然后遍历数组中该位置上的单链表, 如果找到hash和key相等的entry, 就替换value, 返回旧value, 如果没找到就新建一个entry, 放在该位置单链表的头部.
下面重点看下数组扩容的方法.
//数组扩容
void resize(int newCapacity) {
//先保存下数组
HashMapEntry[] oldTable = table;
int oldCapacity = oldTable.length;
//判断数组容量是否达到最大容量
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//新建一个数组, 长度为新容量
HashMapEntry[] newTable = new HashMapEntry[newCapacity];
//把老数组中的所有元素转移到新数组中
transfer(newTable);
table = newTable;
//重新计算数组扩容时的临界值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
void transfer(HashMapEntry[] newTable) {
int newCapacity = newTable.length;
//遍历老数组中所有元素
for (HashMapEntry e : table) {
//遍历单链表中所有元素
while(null != e) {
//先保存当前entry的next
HashMapEntry next = e.next;
//计算当前entry在新数组中的下标
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
//把当前entry放到新数组对应位置上
newTable[i] = e;
//把next及放到单链表头部, 继续循环
e = next;
}
}
}
重新建一个长度是之前2倍的数组, 然后把老数组中所有元素, 重新计算位置后一一保存到新数组中, 这个工作量是相当大的, 所以建议使用HashMap的时候预估一下所用的容量, 初始化时容量稍微大一点, 尽量避免数组扩容.
2. get
public V get(Object key) {
//key为空时获取value
if (key == null)
return getForNullKey();
//key不为null时查找value
Entry entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
//获取key为空的value
private V getForNullKey() {
if (size == 0) {
return null;
}
//遍历数组第0位的单链表, 因为key为null时, hash值和对应下标都是0
for (HashMapEntry e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
//查找key不为null的Entry
final Entry getEntry(Object key) {
if (size == 0) {
return null;
}
//计算出key的hash值
int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
//根据hash值计算出对应下表, 遍历该位置的单链表
for (HashMapEntry 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;
}
get方法比put方法简单很多, 计算出对应下标后, 遍历该位置的单链表, 如果hash值和key都相等就返回, 没有就返回null;
3. contains
containsKey: 是否包含key
containsValue: 是否包含value
containsNullValue: 是否包含null
public boolean containsKey(Object key) {
//看数组中key对应的Entry是否为空
return getEntry(key) != null;
}
public boolean containsValue(Object value) {
if (value == null)
return containsNullValue();
HashMapEntry[] tab = table;
//遍历数组
for (int i = 0; i < tab.length ; i++)
//遍历该位置的单链表
for (HashMapEntry e = tab[i] ; e != null ; e = e.next)
if (value.equals(e.value))
return true;
return false;
}
private boolean containsNullValue() {
HashMapEntry[] tab = table;
for (int i = 0; i < tab.length ; i++)
for (HashMapEntry e = tab[i] ; e != null ; e = e.next)
if (e.value == null)
return true;
return false;
}
很简单, 就是遍历数组, 遍历单链表, 看是否有对应值相等的元素.
4. remove
public V remove(Object key) {
Entry e = removeEntryForKey(key);
return (e == null ? null : e.getValue());
}
final Entry removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
//根据key计算hash值及对应下表
int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
int i = indexFor(hash, table.length);
//保存链表头部元素
HashMapEntry prev = table[i];
HashMapEntry e = prev;
//遍历该位置的单链表
while (e != null) {
//e:当前元素 next:下一个元素 pre:前一个元素
HashMapEntry next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
//如果key对应的entry在头部, 就把头部元素删除, 把next放在链表头.
//如果不在头部, 就删除当前元素, 把next跟在pre后
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
//链表元素下移, 继续查找
prev = e;
e = next;
}
return e;
}
5. clear
public void clear() {
modCount++;
Arrays.fill(table, null);
size = 0;
}
很简单就是把数组清空, 数组长度置空.
HashMap简单介绍完了, 是不是很简单, 下面来看下它的子类LinkedHashMap.