HashMap源码解析

摘要: hashmap的源码解析，全部是自己啃完后的理解，如有不正确的地方还望批评指正

public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
{

//默认初始化大小，如果没有给初始化值的话，大小就是16（2的n次幂），后面的扩容也是2的N次幂
static final int DEFAULT_INITIAL_CAPACITY = 16;

//最大容量，2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;

//系统默认的负载因子（没懂其意义）
static final float DEFAULT_LOAD_FACTOR = 0.75f;

//存放数据的实体（重要）
transient Entry[] table;

//实际存放数据的量
transient int size;

//阈值（没懂）,大小为Entry的长度*loadFactor
int threshold;

//哈希表的负载因子（没懂）
final float loadFactor;

//修改次数
transient volatile int modCount;

//构建函数（初始化容量和hash表的负载）
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)//小于零抛异常
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//保证Entry[]的大小不会超过最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);

// 初始化各个值，除非initialCapacity刚好是2的N次幂，否则初始化Entry[]的容量肯定比传入的initialCapa        //city值要大，并且应该是比initialCapacity大的第一个2的N次幂
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;

this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}

//构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//构造函数
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}

//构造函数
public HashMap(Map<? extends K, ? extends V> m) {
//初始化新map的大小等参数
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
//copy数据，把m中的数据复制到新的集合里面，putAllForCreate的细节在方法内解析
putAllForCreate(m);
}

void init() {
}

//一个自定义的hash算法
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}

//自定义的算法，返回的结果就是在Entry[]数组中的位置
static int indexFor(int h, int length) {
return h & (length-1);
}

//返回具体数据的数量
public int size() {
return size;
}

//判断是否为空
public boolean isEmpty() {
return size == 0;
}

//获取数据
public V get(Object key) {
//key==null的话就找寻是否有key为空值对应的value
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
//这个for循环挺有意思，由于hashmap是数组+链表，所以此循环实际上是找到在Entry[]上的位置，然后循环这个        //位置上的链表，很像XY轴，定位到X轴后再循环在X轴上Y轴的数据
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
//e内存储的hash要和传入的key的hash值相同（e内存储的hash就是e中key的hash值），并且e中的key要和             //传入的key相等，此时返回e的value
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
//否则为空
return null;
}

//返回空键的值，按照之前的算法，传入的key为空的时候，由于存放数值的函数处理的时候把key为空时放到0处，所以    //搜寻地址在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;
}

//看是否有哪个Entry内的key等于传入的key，有的话为true，否则为false
public boolean containsKey(Object key) {
return getEntry(key) != null;
}

//获取key对应的Entry
final Entry<K,V> getEntry(Object key) {
//key为空的时候直接给0，否则计算会抛空指针异常
int hash = (key == null) ? 0 : hash(key.hashCode());
//遍历整个链表
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
//e的key与传入的相等就返回此Entry
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
//否则为空
return null;
}

//存入数据
public V put(K key, V value) {
//key为空的时候特殊处理
if (key == null)
return putForNullKey(value);
//计算key的hash值
int hash = hash(key.hashCode());
//通过key定位到数组的位置
int i = indexFor(hash, table.length);
//遍历i上的链表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//如果找到有一样的（同一个key），就替换此处的值，只替换此处Entry内的value属性值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
//不知道干啥的
e.recordAccess(this);
//返回以前的value  PS：有些API手册上没注明会返回原来的值
return oldValue;
}
}
//修改次数+1
modCount++;
//发现Entry[]的i位置上的链表没有同样的key，就在i上添加值，具体的添加细节看下面的方法注释
addEntry(hash, key, value, i);
//然后返回NULL
return null;
}

//key为空的时候存放value
private V putForNullKey(V value) {
//遍历Entry[]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;
}
}
//同上，0处没发现有等于null的key就添加一个值
modCount++;
addEntry(0, null, value, 0);
return null;
}

//最后一个构造函数new Map(map)的业务方法
private void putForCreate(K key, V value) {
//若key为空仍然用0，否则就计算出hash值
int hash = (key == null) ? 0 : hash(key.hashCode());
//在Entry[]上的位置
int i = indexFor(hash, table.length);
//遍历此位置上的链表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//替换value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
//没找到一样的key就创建一个Entry
createEntry(hash, key, value, i);
}

//第四个构造函数直接调用的方法
private void putAllForCreate(Map<? extends K, ? extends V> m) {
//用迭代器（感觉可以用while(i.hasNext())），遍历m内的所有元素
for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
Map.Entry<? extends K, ? extends V> e = i.next();
//把每个迭代的值用以下方法处理，具体看下面方法的注释
putForCreate(e.getKey(), e.getValue());
}
}

//重新修改map的大小
void resize(int newCapacity) {
//将当前的Entry[]拿出来
Entry[] oldTable = table;
//旧数组的长度（数组的长度，不是数值的数量）
int oldCapacity = oldTable.length;
//若就数组的长度是最大值
if (oldCapacity == MAXIMUM_CAPACITY) {
//修改临界值
threshold = Integer.MAX_VALUE;
return;
}
//用新的传入长度构建一个Entry[]
Entry[] newTable = new Entry[newCapacity];
//复制，把原来Entry[]内的数据都复制到新的Entry[]内
transfer(newTable);
//替换掉旧的数组
table = newTable;
//修改阈值
threshold = (int)(newCapacity * loadFactor);
}

//复制，把原来Entry[]内的数据都复制到新的Entry[]内
void transfer(Entry[] newTable) {
//把当前数组（旧数组）“存盘”
Entry[] src = table;
//新数组的长度
int newCapacity = newTable.length;
//遍历旧的数组
for (int j = 0; j < src.length; j++) {
//旧数组的数据“存盘”
Entry<K,V> e = src[j];
if (e != null) {
//清空位置为j上的所有数据
src[j] = null;
//开始循环之前j位置上的链表
do {
//这个循环有点意思，文字表述有点困难，后续补图
//首先Entry是个链表，它内部的next指向另一个Entry
//理解以上的东西后，以下循环以这个链表上的第一个数据为例：
//先把链表从第二个值开始的链表（当前循环值的后一个）“存盘”(1)，然后在新的数组上计算出此链表                 //上第一个值应该存放的位置i(2),然后把这个数组i上的数据拼接到此链表第一个数据之后，形成一个新                //的链表（3），再把拼接后的链表放到数组的i处（4），然后把从第二个值开始的链表赋给e（5）,接下                //来就是继续循环,知道e==null为止（6）。然后再循环此数组上的下一个链表
Entry<K,V> next = e.next;  //1
int i = indexFor(e.hash, newCapacity);//2
e.next = newTable[i];//3
newTable[i] = e;//4
e = next;//5
} while (e != null);//6
}
//copy完之后数据的位置是有变化的，先不说在新数组上的位置变了，连在链表上的位置也变了
//整体的调整容量思路就是:创建一个具有新容量的数组,然后把旧数组的值全部复制到新的数组里面，同时清             //空旧数组的值（消除指针），等待回收
}
}

//把m的值copy到原来的数组内，如果key相同就替换掉原来的value，如果key不同则加入
public void putAll(Map<? extends K, ? extends V> m) {
int numKeysToBeAdded = m.size();
//传入的m为空，就返回空
if (numKeysToBeAdded == 0)
return;

//如果m的size大于当前的阈值，则通过计算扩大后的m.size()会不会比table.length大，如果大则执行后续操作
//ps：小小的计算了一下，发现只要m.size>阈值，newCapacity < targetCapacity就几乎是恒成立的
//大概就是4/3*m.size<table.length<4/3*m.size+1，在这种情况下newCapacity 才可能大于targetCapacity
if (numKeysToBeAdded > threshold) {
int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
int newCapacity = table.length;
while (newCapacity < targetCapacity)
//给原来的table.length扩容
newCapacity <<= 1;
if (newCapacity > table.length)
//调整容量的大小
resize(newCapacity);
}
//开始迭代
for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
Map.Entry<? extends K, ? extends V> e = i.next();
//把迭代的值扔进原来的put中,执行结果很像jquery的深拷贝(有就替换，没有就添加)
put(e.getKey(), e.getValue());
}
}

//移除Entry[]上e.key=key的Entry,并返回此Entry处的value
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}

//按照Key移除的业务方法
final Entry<K,V> removeEntryForKey(Object key) {
//key为空hash直接给0
int hash = (key == null) ? 0 : hash(key.hashCode());
//数组的地址
int i = indexFor(hash, table.length);
//存几个盘
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;

//开始循环i处的链表，先不看if语句，先理解这个循环，其实很简单，设两个指针，以e为标准，prev一直是e的         //前一个指针，循环一轮这俩指针就往后移动一格
while (e != null) {
Entry<K,V> next = e.next;
Object k;
//找到对应的值
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
//修改次数+1
modCount++;
//数量-1
size--;
//如果e==prev（这种情况只会是删除i处的链表的第一个值）,就把链表上的第二个值放到第一个上
if (prev == e)
table[i] = next;
else
//否则的话，就把prev指向下一个数据的指针移到第三个值身上（跳过第二个值e）
prev.next = next;
e.recordRemoval(this);
//返回这个Entry
return e;
}
向后移动指针
prev = e;
e = next;
}

return e;
}

//同上，只不过此时传入的是Object对象，还要判断一下，如果此对象不是Entry格式的，就返回空
final Entry<K,V> removeMapping(Object o) {
if (!(o instanceof Map.Entry))
return null;

Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
Object key = entry.getKey();
int hash = (key == null) ? 0 : hash(key.hashCode());
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;
if (e.hash == hash && e.equals(entry)) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}

return e;
}

//清仓
public void clear() {
modCount++;
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
tab[i] = null;
size = 0;
}

//找找是不有这个value这个值
public boolean containsValue(Object value) {
//等于空时特殊处理
if (value == null)
return containsNullValue();
//遍历数组的每个值
Entry[] tab = table;
for (int i = 0; i < tab.length ; i++)
//遍历每个链表上的每个值
for (Entry e = tab[i] ; e != null ; e = e.next)
if (value.equals(e.value))
return true;
return false;
}

//跟上面一样，只不过专门找寻value为空的value，然后返回boolen值
private boolean containsNullValue() {
Entry[] tab = table;
for (int i = 0; i < tab.length ; i++)
for (Entry e = tab[i] ; e != null ; e = e.next)
if (e.value == null)
return true;
return false;
}

//返回一个hashmap对象，这个对象本身是新的，内部的Entry[]数组也是新的，但是，key和value是引用过来的
//实际上，putAllForCreate（this）这个方法也是引用各变量的地址，内部属性并没有在堆内存中开辟新的空间
public Object clone() {
HashMap<K,V> result = null;
try {
//在内存中开辟空间，用于存放一个新的hashmap
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {

}
//初始化长度等各种属性
result.table = new Entry[table.length];
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
//this指当前的Hashmap,就是旧的hashmap，此方法上面有注释，只是把key,value,hash和i存入新的hashmap内
result.putAllForCreate(this);

return result;
}

//这就是Entry的真面目，内部类，也叫桶，我觉得叫链条更有意思 - -||
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
//就是因为每个桶里都有另一个桶，相当于指向（其实就是指向），另一个桶，这样就把整个链条穿起来
Entry<K,V> next;
final 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;
}

//自定义equels方法
public final boolean equals(Object o) {
//判断类型
if (!(o instanceof Map.Entry))
return false;
//强转一个
Map.Entry e = (Map.Entry)o;
//当前key
Object k1 = getKey();
//传入的key
Object k2 = e.getKey();
//判断key和value是否相同，此处要求内存地址或者内容相同
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;
}

//重写hashcode方法，为了equals准备
public final int hashCode() {
return (key==null   ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}

//没啥说的
public final String toString() {
return getKey() + "=" + getValue();
}

//没啥说的，没懂有什么用
void recordAccess(HashMap<K,V> m) {
}

void recordRemoval(HashMap<K,V> m) {
}
}

//创建新的桶
void addEntry(int hash, K key, V value, int bucketIndex) {
//原来bucketIndex处的链表存盘
Entry<K,V> e = table[bucketIndex];
//创建新的桶，然后把之前的链表连接到新的桶上，形成新的链表
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
//数据量超过阈值之后就扩大table.length，然后要重新计算阈值，老规矩还是大于等于2 * table.length的第        //一个2的n次幂*3/4
if (size++ >= threshold)
resize(2 * table.length);
}

//创建新的桶，和上个方法差不多，只是不用扩大阈值，因为调用这个方法的方法都知道，创建的桶是不会超过阈值的
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
size++;
}

//实现迭代器
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next;   //下一个值
int expectedModCount;  // 用来存储改变的次数
int index;    //当前指针
Entry<K,V> current;    //当前值

//构造方法
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();
//next赋给一个新的桶（next在构造器里被赋值过）
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
//next的指针往后移一个单位，并判断这个链表是否到最后一个值
if ((next = e.next) == null) {
//如果是最后一个值，则index指向下一个数组的位置，next则指向下一个数组的第一个桶
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
//e赋给当前值
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;
}

}

//把以上的类当父类继承，next()只返回value
private final class ValueIterator extends HashIterator<V> {
public V next() {
return nextEntry().value;
}
}

//同样继承，但是只返回桶的key
private final class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}

//返回桶
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}

//没加访问权限符，默认是friendly，只有同类和同包中的类才能访问
Iterator<K> newKeyIterator()   {
return new KeyIterator();
}
Iterator<V> newValueIterator()   {
return new ValueIterator();
}
Iterator<Map.Entry<K,V>> newEntryIterator()   {
return new EntryIterator();
}

//生命一个Set
private transient Set<Map.Entry<K,V>> entrySet = null;

//赋值ks一个new KeySet()
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}

//继承抽象Set，一个Set的视图
private final class KeySet extends AbstractSet<K> {
//实现接口的方法，返回之前写好的方法，返回桶的key
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();
}
}

//把桶的value转化成为Collection类型，返回Collection类型的视图
public Collection<V> values() {
Collection<V> vs = values;
return (vs != null ? vs : (values = new Values()));
}

//定义一个类，实现AbstractCollection接口，相当于创建一个AbstractCollection类型的类
private final class Values extends AbstractCollection<V> {
public Iterator<V> iterator() {
return newValueIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
HashMap.this.clear();
}
}

//返回一个entrySet
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}

//entrySet的视图
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}

//其实和keySet是一样的，只不过这里的迭代器中的next方法返回的是entry，keyset中的迭代器方法返回的是key
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 void writeObject(java.io.ObjectOutputStream s)
throws IOException
{
Iterator<Map.Entry<K,V>> i =
(size > 0) ? entrySet0().iterator() : null;

s.defaultWriteObject();

s.writeInt(table.length);

s.writeInt(size);

if (i != null) {
while (i.hasNext()) {
Map.Entry<K,V> e = i.next();
s.writeObject(e.getKey());
s.writeObject(e.getValue());
}
}
}

private static final long serialVersionUID = 362498820763181265L;

private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{

s.defaultReadObject();

int numBuckets = s.readInt();
table = new Entry[numBuckets];

init();

int size = s.readInt();

for (int i=0; i<size; i++) {
K key = (K) s.readObject();
V value = (V) s.readObject();
putForCreate(key, value);
}
}

// These methods are used when serializing HashSets
int   capacity()     { return table.length; }
float loadFactor()   { return loadFactor;   }
}

最后一段迭代器解释的不是很清楚，可以逆向来想，collection和set接口都有定义这些类的方法、入参和返回参数，那如果要返回这些类型的对象，就需要一个类去实现这些接口，然后被返回。而这些接口中都有定义迭代器的方法，那就需要返回一个迭代器的对象，此时就写一个HashIterator抽象类，并实现Iterator接口，但又由于需求的不同（有些要返回value，有些要返回key，有些又要返回entry），所以就定义为抽象类，这样就不用实现Iterator下的所有方法，下面再写三个类，继承HashIterator，并实现next()方法，用来返回不同的需求值。然后我们在定义一个方法，用来返回刚才编写的类的对象，将此方法放入collection和set的实现类的Iterator方法中，这样就返回了相应的视图

PS:不是太了解为什么要多加一个方法去返回三个迭代器对象，目测应该是出于访问权限的关系，可能其他的类中也需要调用到这个方法，所以设置成friendly（没加访问权限符，默认为friendly）。