java源码解读之HashMap------jdk 1.7

1. 定义
Map与list不同是一种键值对的集合,包含了key和value.hashmap是用hash处理分配存储位置的对map接口的一种实现.

public interface Map<K,V> {
//获得容器内有多少元素
int size();
//获得容器内元素是否为零
boolean isEmpty();
//是否包含传入值
boolean containsKey(Object key);
//是否包含传入value
boolean containsValue(Object value);
//根据传入key获得value
V get(Object key);
//增加对象
V put(K key, V value);
//移除对象
V remove(Object key);
//根据传入集合增加多个对象
void putAll(Map<? extends K, ? extends V> m);
//清空容器
void clear();
//获得key的set类型集合
Set<K> keySet();
//获得value的集合
Collection<V> values();
//获得键值对的set集合
Set<Map.Entry<K, V>> entrySet();
//实现map的核心,put后都是用entry进行存储
interface Entry<K,V> {
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
}
boolean equals(Object o);
int hashCode();
}

//AbstractMap是实现了map接口的一部分方法的抽象类,Cloneable表示支持克隆,Serializable接口表示启用序列化功能
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

2. 属性

//默认容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大的容量,容量数最好是2的n次幂
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认负载因子,size到达容量乘于负载因子就进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//空的entry数组,创建hashmap的时候使用
static final Entry<?,?>[] EMPTY_TABLE = {};
//添加对象使用的entry数组
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//总共有多少元素
transient int size;
//下次扩容的临界值=capacity*loadFactor
int threshold;
//负载因子
final float loadFactor;
//修改次数
transient int modCount;
//默认阈值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
//哈希种子，实例化HashMap后在将要使用前设置的随机值，可以使得key的hashCode冲突更难出现
transient int hashSeed = 0;

3.构造器

//自己设置临界值和负载因子的构造
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);

this.loadFactor = loadFactor;
threshold = initialCapacity;
//这个里面没有代码
init();
}
//单独设置临界值,负载因子使用默认值
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//用默认临界值和默认负载因子创建构造器
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//根据传入的map的实现创建hashmap
public HashMap(Map<? extends K, ? extends V> m) {
//判断传入map的capacity是否大于默认的容量16,如果大于则使用计算后的容量,否则使用默认容量
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
//根据容量重新计算临界值
inflateTable(threshold);
//把传入map中的键和值遍历之后放入map
putAllForCreate(m);
}
//现在来看看inflateTable方法里面是什么
private void inflateTable(int toSize) {
//根据上方传入的临界值计算出容量
int capacity = roundUpToPowerOf2(toSize);
//根据负载因子重新计算,再通过比较获得小的那个临界值
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建对应容量的entry数组
table = new Entry[capacity];
//判断HashMap对象是否需要将存储数据的哈希表扩展到指定的容量,如果需要就进行扩容
initHashSeedAsNeeded(capacity);
}
//简单解析下遍历map放入新map的方法
private void putAllForCreate(Map<? extends K, ? extends V> m) {
//遍历key,value调用方法放入新map
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putForCreate(e.getKey(), e.getValue());
}
private void putForCreate(K key, V value) {
//判断下key是否为null,为null进行特殊处理
int hash = null == key ? 0 : hash(key);
//获得hash计算后应该放置的位置
int i = indexFor(hash, table.length);
//遍历map如果map中已有传入map相同的key值,则覆盖value
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
//如果没有对应key则新建一个entry放入
createEntry(hash, key, value, i);
}
//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++;
}
//hashmap有两层结构,一层是entry数组,entry是一个链表
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}

4.解析部分方法源码

4.1 增加方法

public V put(K key, V value) {
//如果table还是默认数组,重新计算临界值
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//如果key为null,调用封装的方法放在table[0]的位置
if (key == null)
return putForNullKey(value);
//计算hash值的
int hash = hash(key);
//计算出对应hash应该放置的位置,内部代码为return h & (length-1),这个比取模运算更快,只有当容量是2的n次方倍的时候才成立
int i = indexFor(hash, table.length);
//遍历查找key,有则覆盖value
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;
}
}
//没有则新增entry
modCount++;
addEntry(hash, key, value, i);
return null;
}
//现在来看看具体是怎么计算位置的
static int indexFor(int h, int length) {
//因为length是2的n次方,二进制就是1+n个0,(length-1)的二进制即为0+n个1,例如8的二进制为1000,8-1的二进制为0111.
//所以当length为2的次方的时候,h & (length-1)等价于h%(length-1),而且比后一种更快
return h & (length-1);
}
//仔细看看addEntry方法
void addEntry(int hash, K key, V value, int bucketIndex) {
//当size大于临界值,并且对应位置已经有存放entry时扩容table
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);
}
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];
//复制旧map数据到新的map
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);
//需要想清楚的关键逻辑在这里
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}

4.2 删除方法

public V remove(Object key) {
//调用了一个封装方法
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
//因为put方法放置null位置为table[0],所以若为null的hash直接为0,负责经过hash方法计算
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
//后续循环才会进这里,把链表中间去掉要删除的entry,然后两端连接
prev.next = next;
//这是个空方法
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}

return e;
}

4.3 修改方法
这个没什么好说的,修改方法就是put方法,同个key,value会覆盖

4.4 查找方法

public V get(Object key) {
//如果为null特殊处理
if (key == null)
return getForNullKey();
//根据key获得对应entry
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
private V getForNullKey() {
if (size == 0) {
return null;
}
//前面已说过,key为null的entry是放在table[0]的位置
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) {
if (size == 0) {
return null;
}
//根据hash值获得对应entry链表,然后遍历key获得对应entry
int hash = (key == null) ? 0 : hash(key);
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;
}

4.5 遍历方法

//这是一个视图,修改或者删除都会对原有map造成影响
private transient Set<Map.Entry<K,V>> entrySet = null;
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
//获得数据是通过下方一层层调用实现的,最后遍历每个nextEntry
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<K,V> e = (Map.Entry<K,V>) o;
Entry<K,V> candidate = getEntry(e.getKey());
return candidate != null && candidate.equals(e);
}
public boolean remove(Object o) {
return removeMapping(o) != null;
}
public int size() {
return size;
}
public void clear() {
HashMap.this.clear();
}
}
Iterator<Map.Entry<K,V>> newEntryIterator()   {
return new EntryIterator();
}
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
//是通过调用这个next方法来进行遍历的
public Map.Entry<K,V> next() {
return nextEntry();
}
}
//nextEntry是HashMap中一个内部抽象类HashIterator的一个方法,补充一下HashIterator的构造器
HashIterator() {
expectedModCount = modCount;
if (size > 0) {
Entry[] t = table;
//找到第一个不等于null的entry赋值给next
while (index < t.length && (next = t[index++]) == null)
;
}
}
final Entry<K,V> nextEntry() {
//保证遍历过程中没有修改
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
//如果next的下一个entry是null,通过循环查找下一个不为null的entry
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
//相当于把下一个entry赋值给现在的entry,然后return给调用者
current = e;
return e;
}