HashMap源码解读

首先我们需要在eclipse中打开HashMap源码，按住ctrl键，鼠标左键单击HashMap类，选择相应的源码所在路径，打开即可。

包括注释，HashMap源码共有1189行。

HashMap源码重点：

(1)HashMap表实现了Map接口，它提供可以选择的map操作，并且可以有null的键和值。

(2)除了HashMap是非线程安全的和可以有null的键和值外。HashMap和HashTable大体等价。即HashTable不能有null的键和值，并且线程安全，因为HashTable给整张表加锁。

(3)HashMap是无序的，即插入顺序和输出顺序不一致。可以用ListedHashMap实现有序操作。

(4)HashMap用桶(buckets)来储存元素，桶的个数不能太大，且负载因子不能太小。初始容量和负载因子会影响循环效率，当Entry[]中存的键值对数目超过HashMap所能容纳最大值时，会发生扩容，负载因子默认是0.75，初始容量默认是16，扩容意思是内部的数据结构会rebuilt.扩容的结果是容量变为原来的两倍。

(5)HashMap是非线程安全的，但是collections类中提供了一个静态方法SynchronizedMap，创建了一个线程安全的Map对象，这是最好的办法处理HashMap的非线程安全问题。

Map m = Collections.synchronizedMap(new HashMap(…));

(6)Iterator是fail-fast，快速失的，在用Iterator遍历整个Map的时候，如果采用索引进行删除的操作，就会抛出异常。ConcurrentModificationException

前面这些是源代码开始前的声明和简单解释，接下来我们开始分析源码：

public class HashMap < K,V>

extends AbstractMap< K,V>

implements Map< K,V>, Cloneable, Serializable{}

—->HashMap继承抽象类AbstractMap并且实现了Map接口。

接下来看构造函数：

(1)传入指定的初始容量和负载因子：
//确保传入的参数(容量和负载因子)合法。
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
int capacity = 1;   //初始容量
while (capacity < initialCapacity)   //确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}

(2)负载因子是默认的，初始容量是传进来的：
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

(3)初始容量和负载因子都采用默认值：
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

***HashMap的put和get方法：

(1)get方法

public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);

return null == entry ? null : entry.getValue();
}

*/
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}

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;
}

private V getForNullKey() {
if (size == 0) {
return null;
}
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}

根据key的hashCode得到对应的桶的位置，再根据key的equals方法得到链表中具体的value值。

(2)put方法：

public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
//若“key为null”，则将该键值对添加到table[0]中。
if (key == null)
return putForNullKey(value);
//若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
//搜索指定hash值在对应table中的索引
int i = indexFor(hash, table.length);
//循环遍历Entry数组,若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
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++;
//将key-value添加到table[i]处
addEntry(hash, key, value, i);
return null;
}

private V putForNullKey(V value) {
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;
}

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);
}

当程序试图将一个key-value对放入HashMap中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但key不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部。

Entry是单向链表，是一个类，存储的是key-value对象，实现了Map.Entry接口。equals方法用来判断两个Entry的key和value是否相等，相等返回true，不相等返回false。HashMap实际上就是一个Entry数组。垂直方向判断处于哪一个table，水平方向判断放在Entry数组的哪个位置。

---->Entry类实现了Map.Entry接口:
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
int hash;
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
}
public final String toString() {
return getKey() + "=" + getValue();
}
void recordAccess(HashMap<K,V> m) {
}
void recordRemoval(HashMap<K,V> m) {
}
}

HashTable中，我们对哈希表的散列一般用除留余数法，这样可以保证均匀散列，但取模会用到除法，效率低，所以在HashMap中采用h&(length-1)来代替取模。效率提高，且能实现均匀散列。

关于resize()方法：重新调整HashMap的大小。

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];
//用来将原先table的元素全部移到newTable里面
transfer(newTable);
//再将newTable赋值给table
table = newTable;
//重新计算临界值
threshold = (int)(newCapacity * loadFactor);
}

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;
}
}
}

关于EntrySet和KeySet：

EntrySet是java中的一个对象，一般可以通过map.entrySet()得到。

(1)entrySet实现了Set接口，里面存放的是键值对。一个K对应一个V。

(2)entrySet是用来遍历map的一种方法。

Set< Map.Entry< String, String>> entryseSet=map.entrySet();

for (Map.Entry< String, String> entry:entryseSet) {

System.out.println(entry.getKey()+”,”+entry.getValue());

}

通过getKey（）得到K，getValue得到V。

keySet也是遍历Map的一种方法，主要存的是Map的key，主要用来遍历key.

Set set = map.keySet();

for (String s:set) {

System.out.println(s+”,”+map.get(s));

}

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();
}
}

private final class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
}

HashMap源码中还实现了ContainsKey()和ContainsValue()方法，ContainsKey用来快速判断有没有给定的查询值key，ContainsValue用来快速判断有没有给定的查询值value.