java源码分析之HashMap（jdk1.6）
我是java新手，刚刚学习不久，有不足之处请大家谅解，同时请大家多多指教
学习hashMap之前，我复习了下数据结构中的hash表，解决hash冲突采用的拉链法，如下图所示：
源码：
1.HashMap继承自AbstractMap，实现了Map接口（这些内容可以参考《Java集合类》）。来看类的定义。
public class HashMap<K,V>extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, SerializableMap接口定义了所有Map子类必须实现的方法。Map接口中还定义了一个内部接口Entry。（Entry将在后面有详细的介绍）
AbstractMap也实现了Map接口，并且提供了两个实现Entry的内部类：SimpleEntry和SimpleImmutableEntry
HashMap中定义的属性：
/*
初始容量，必须为2的幂次方
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
/*
定义最大的容量，
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
装载因子，后面会有介绍
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/*
定义一个默认的存储Entry对象的数组
*/
static final Entry<?,?>[] EMPTY_TABLE = {};
/*
初始化，table
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
/*
存储键值对的个数
*/
transient int size;
/**
极限值，当size大于这个值的时候，需要进行增容的操作
等于容量乘以装载因子
*/
int threshold;
/*
装载因子，我们可以进行改变的
*/
final float loadFactor;
/**
修改的次数，可以用来在迭代器中判断操作是否同步
*/
transient int modCount;
下面再来看下构造函数：
/**
*使用默认的容量及装载因子构造一个空的HashMap
*/
public HashMap() {
//初始化装载因子，采用默认大小
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//计算下次需要调整大小的极限值
table = new Entry[DEFAULT_INITIAL_CAPACITY];//根据默认容量（16）初始化table
//这里是一个空函数，不知道用来做什么，可能方便以后的扩展
init();
}
/**
* 根据给定的初始容量的装载因子创建一个空的HashMap
* 初始容量小于0或装载因子小于等于0将报异常
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " + nitialCapacity);
//调整最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
int capacity = 1;
//设置capacity为大于initialCapacity且是2的幂的最小值
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
//设置极限值，
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}
/**
*根据指定容量创建一个空的HashMap
*/
public HashMap(int initialCapacity) {
//调用上面的构造方法，容量为指定的容量，装载因子是默认值
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
*通过传入的map创建一个HashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，装载因子为默认值
*/
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
//putAllForCreate看方法名就是创建的时候将传入的map全部放入新创建的对象中。该方法中还涉及到其他方法，将在后面介绍
putAllForCreate(m);
}先看初始化table时均使用了Entry，这是HashMap的一个内部类，实现了Map接口的内部接口Entry，下面看下在HashMap内部中定义的内部类：
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;//在上面图上，可以知道：解决hash冲突的方式为：拉链法，即链表，这里为下一个节点的引用
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;
}
//在hashMap中判断key唯一性，需用用到equals这个方法，还一个方法为hashCode
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();
// Key相等且Value相等则两个Entry相等，则不需要插入
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是Key的hashCode和Value的hashCode的异或的结果
public final int hashCode() {
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
// 重写toString方法，是输出更清晰
public final String toString() {
return getKey() + "=" + getValue();
}
/**
*当调用put(k,v)方法存入键值对时，如果k已经存在，则该方法被调用（为什么没有内容？）
*/
void recordAccess(HashMap<K,V> m) {
}
/**
* 当Entry被从HashMap中移除时被调用（为什么没有内容？）
*/
void recordRemoval(HashMap<K,V> m) {
}
}分析HashMap中的其他方法，从最常用的put和get开始看起：
public V put(K key, V value) {
// key可以分为：null和非空两种情况
if (key == null)
//采用添加key为空的方法
return putForNullKey(value);
//计算hash值
int hash = hash(key.hashCode());
//计算hash值在数组中映射的下标
int i = indexFor(hash, table.length);
//查找是否有hash相等和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++; //修改次数
//实现添加，再添加的时候，需要判断是否需要增容的操作
addEntry(hash, key, value, i);
return null;
}当存入的key是null的时候将调用putForNUllKey方法，暂时将这段逻辑放一边，看key不为null的情况。先调用了hash(int h)方法获取了一个hash值。
/*
这个方法的主要作用是防止质量较差的哈希函数带来过多的冲突（碰撞）问题。Java中int值占4个字节，即32位。根据这32位值进行移位、异或运算得到一个值
*/
static int hash(int h) {
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}获取下标的方法：
//根据hash值映射到数组中的下标，采用位运算，速度快
static int indexFor(int h, int length) {
return h & (length-1);
}实现添加节点：
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);
//判断是否需要增容的操作，需要扩大2倍
if (size++ >= threshold)
resize(2 * table.length);
}增容：
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
// 这个if块表明，如果容量已经到达允许的最大值，即MAXIMUN_CAPACITY，则不再拓展容量，而将装载拓展的界限值设为计算机允许的最大值。
// 不会再触发resize方法，而是不断的向map中添加内容，即table数组中的链表可以不断变长，但数组长度不再改变
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 创建新数组，容量为指定的容量
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
// 设置下一次需要调整数组大小的界限
threshold = (int)(newCapacity * loadFactor);
}实现整体节点的复制：到新的容器中去
void transfer(Entry[] newTable) {
// 保留原数组的引用到src中，
Entry[] src = table;
// 新容量使新数组的长度
int newCapacity = newTable.length;
// 遍历原数组
for (int j = 0; j < src.length; j++) {
// 获取元素e
Entry<K,V> e = src[j];
if (e != null) {
// 将原数组中的元素置为null
src[j] = null;
// 遍历原数组中j位置指向的链表
do {
Entry<K,V> next = e.next;
// 根据新的容量计算e在新数组中的位置
int i = indexFor(e.hash, newCapacity);
// 采用头插法
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}从上面的代码可以看出，HashMap之所以不能保持元素的顺序有以下几点原因：第一，插入元素的时候对元素进行哈希处理，不同元素分配到table的不同位置；第二，容量拓展的时候又进行了hash处理；第三，复制原表内容的时候链表被倒置。
下面介绍下：put的所有方法
public void putAll(Map<? extends K, ? extends V> m) {
int numKeysToBeAdded = m.size();
if (numKeysToBeAdded == 0)
return;
/*
为什么判断条件是numKeysToBeAdded，不是两者之和了？
查了下资料：可能是为了避免有相同元素
*/
if (numKeysToBeAdded > threshold) {
int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
int newCapacity = table.length;
//记住：容量一定为2的幂次方
while (newCapacity < targetCapacity)
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(e.getKey(), e.getValue());
}
}上面出现了entrySet方法，它是返回是一个迭代器，在后面会介绍，本质就是一个代理类，继续介绍put方法
//实现把一个key为null节点添加，计算hash值得时候，可以看到：key为null的时候，hash值就是0，映射到数组的下标也是0
private V putForNullKey(V value) {
//查找key是否已经存在
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;
}/*
还记得这个方式是在：构造函数中，里面一个map结合来初始化的时候，出现过:
思路就是：迭代一个元素，就添加一个元素到新的容器中去
*/
private void putAllForCreate(Map<? extends K, ? extends V> 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());
}
}//基本思想和：addEntry一样
1.key是否为null 2。查找key是否已经存在， 3。不存在添加，存在修改value
private void putForCreate(K key, V value) {
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
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;
}
}
//添加元素
createEntry(hash, key, value, i);
}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++;
}上面已经把put方法介绍完了，下面开始介绍get方法
/**
思路：
1。获取的key是否为null ，为null =====进行 getForNullKey()
2 不为空，根据hash，找到在数组中的下标
3.查找数组中指定下标处的链表，进行判断hash和key，找到返回value，没有找到返回null
*/
public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
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.equals(k)))
return e.value;
}
return null;
}private V getForNullKey() {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}上面把put和get方法都看完了，下面看下其他的方法：
HashMap没有提供判断元素是否存在的方法，只提供了判断Key是否存在及Value是否存在的方法，分别是
1）containsKey(Object key)
2）containsValue(Object value)
containsKey(Object key)方法很简单，只是判断getEntry(key)的结果是否为null，是则返回false，否返回true。
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
final Entry<K,V> getEntry(Object key) {
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;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}/**
分为：value为空和非空的情况
遍历所有节点：找到相关key的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;
}
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中“删除”相关的操作，有remove(Object key)和clear()两个方法
/**
思路： 分为key为null和非空的情况
1。不为空的情况，根据hash找到在数组中的映射下标，找到给链表的头结点
2。找到该节点，需要判断的是，删除的节点是否为头结点
3。删除节点
4。没有找到，返回null
*/
final Entry<K,V> removeEntryForKey(Object key) {
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;
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;
}/**
直接将table数组内容都置空，这样所有的链表都已经无法访问，Java的垃圾回收机制会去处理这些链表。table数组置空后修改size为0。
*/
public void clear() {
modCount++;
/**
这里有个问题，不直接对table进行操作，而是通过其他变量来操作
我的理解是：直接对table操作的话，可能会改变table引用的对象
*/
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
tab[i] = null;
size = 0;
}下面看HashMap中的entrySet（） keySet（）和Values（）方法
相同点：它们都是通过代理类实现的：
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
//返回的是一个：EntrySet内部类对象，基本操作都是调用HashMap内部的迭代器进行操作的
return es != null ? es : (entrySet = new EntrySet());
}private final class EntrySet extendsAbstractSet<Map.Entry<K,V>> {
/**
返回迭代器
*/
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
//直接调用HashMap中的方法，判断是否包含这个节点对象
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);
}
//直接调用HashMap中删除方法
public boolean remove(Object o) {
return removeMapping(o) != null;
}
//返回数据的个数
public int size() {
return size;
//直接调用HashMap中方法
public void clear() {
HashMap.this.clear();
}
}看到了什么？这个类根本就没属性，它只是个代理。因为它内部类，可以访问外部类的内容，debug的时候能看到的属性都是继承或者外部类的属性，输出的时候其实也是调用到了父类的toString方法将HashMap中的内容输出了。看newEntryIterator()这个迭代器：
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator();
}//继承HashMap中的迭代器，
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
//调用HashIterator迭代器中的方法
return nextEntry();
}
}下面看下HashIterator迭代类：
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // current slot
Entry<K,V> current; // current entry
HashIterator() {
expectedModCount = modCount;
if (size > 0) {
Entry[] t = table;
/*
这个方法：
1。next为数组中index处的链表下个节点的引用
2。当给节点为null时，获取数组中下一个index，（即下一个链表的头结点）
*/
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();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
//删除，调用的是HashMap中的方法
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;
}
}keySet()
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}
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();
}
}
Iterator<K> newKeyIterator() {
return new KeyIterator();
}
private final class KeyIterator extends HashIterator<K> {
public K next() {
//直接调用hashmap中迭代器
return nextEntry().getKey();
}
}上面keySet是不是和entrySet方法相似，是的，他们都是一个代理类，具体的都是调用hashmap中的迭代器进行操作的，继续看下：
values()
public Collection values() {
Collection vs = values;
return (vs != null ? vs : (values = new Values()));
}
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();
}
}
public Collection<V> values() {
Collection<V> vs = values;
return (vs != null ? vs : (values = new Values()));
}
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();
}
}
Iterator<V> newValueIterator() {
return new ValueIterator();
}
private final class ValueIterator extends HashIterator<V> {
public V next() {
return nextEntry().value;
}
}上面的values()方法是不是和keySet（）方法一样的， values()方法也一样是代理。只是Values类继承自AbstractCollention类，而不是AbstractSet
109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
