本文详细解析了HashMap的源码实现，包括类实现、源码分析、内部类Entry、主要方法如put、get、remove以及常用方法如keySet、entrySet和values的实现。特别关注了HashMap与AbstractMap的关系，以及如何通过内部类和方法实现不可修改的映射。通过对比HashMap与HashTable，探讨了它们在实现细节上的差异。
一、HashMap介绍：
上面一篇介绍了hashTable,这里HashMap的作用就不多啰嗦了。HashMap 实现的功能和hashTable 差不多，具体实现和功能我们从源码进行分析。
二、源码分析：
2.1 类实现：
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable{...}
这里我们可以看到继承了 AbstractMap<K,V> 还实现了 Map<K,V>，其他的参考hashTable,其实 AbstractMap<K,V> 去看源码知道已经实现了Map<K,V> 接口，为什么这里还需要去实现呢？很多人这里有有疑问，觉得很啰嗦，下面我谈一下介绍，和自己的看法.
Map 接口提供了键值对 这类型数据的通用的方法，而AbstractMap 这是对Map实现的抽象类，我们知道一般抽象类都是用来定义一个概念，一种通用的，不指向具体事物。
这里举个例子：假设我们知道动物都有 eat(food) 的行为，相当于Map. 然后我们设计一个抽象类去实现 void eat(food) {System.out.println(food);} 相当于AbstractMap。然后这个时候我们去实现各个动物比如：人，熊猫等等，都去继承这个抽象类，相当于hashMap , TreeMap 一样，这样我们就可以省略eat 这个通用的实现了。当然实际上这些通用实现可能不满足我们的需求，那么我就要从写。
事实上这里还是没明白为什么 HashMap 还要实现Map接口，因为抽象类已经实现了啊。为啥还要实现呢？其实你进入AbstractMap ，仔细观察会发现：
public abstract Set<Entry<K,V>> entrySet();
这里其实没有对 entrySet 进行实现的，相当于复制了Map的接口方法。我们从JDK 解释中明白：
1.AbstractMap 提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作。
2.要实现不可修改的映射，编程人员只需扩展此类并提供 entrySet 方法的实现即可。
第一句话很好理解，提供方便，第二句话强调了 实现不可修改的映射，也就是说我们继承了AbstractMap ，实现entrySet()方法，那么当前类的集合就是不可修改的了。具体点说，就是你调用 put(),putAll(),remove(),clear() 方法，数据都会存在，并且put()还会报错，具体请看源码和API。
好了，说了这么多，其实是简单解释了AbstractMap 的作用。而实现Map 接口，从功能上来说，没啥作用，因为去掉也没影响。但是从接口上来说，我们可以从JAVA 集合的关系图中接口图就能看出，Map Collection Itertor 是最顶层的东西，我们习惯面向接口编程，这样我们的hashMap 也能能直接指向Map 接口，整个结构更加的完整，这是我的想法，请补充指正！下面继续进行 代码的详细研究吧！
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;// 0.75
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];// 16
init();
}
// 这里我们new HashMap 无论带参数 或者不带参数，主要都是设置增长因子0.75
// 当前增长的位置
// 以及Entry 的数组，这里可以参看hashTable ,下面继续看 Entry 类
static class Entry<K,V> implements Map.Entry<K,V> {
// 这是定义的内部类，Key value 内部属性，
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;
}
public final boolean equals(Object o) {
// 这里对类型 key value 地址值 和 值得判断
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() {
// 这里是对key 和 value 两个的地址值 进行 异或运算，得出的hashcode
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
// 这两个方法 真没看懂，有什么作用。。。
// 知道了人，麻烦帮帮忙解释下
// 当然因为这方法在put remove 等地方都会自动调用估计在扩展的里面的东西留
// 下扩充空间吧
void recordAccess(HashMap<K,V> m) {
}
void recordRemoval(HashMap<K,V> m) {
}
}我们可以看到，hashMap 也是一个内部类的数组，内部类 有ket value 属性而已，下面看看主要方法实现
// 可以看到 这里是有返回值的 ，而且是返回的value
public V put(K key, V value) {
if (key == null)
// 可以看出 key 是可以为null的。并且对值 也进行了操作，请看下面
return putForNullKey(value);
int hash = 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.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
// 这里做了便利，对key 为null 的值
if (e.key == null) {
V oldValue = e.value;
// 这里进行了赋值操作，并且返回的是 旧的一个值
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 数据自增一
modCount++;
// 这里指定了 key 为null 的元素存放的位置，从下面的方法 以及构造，我们看出
// 所有key 为null 的存放位置，默认是放在0的位置，也就是数组第一个
addEntry(0, null, value, 0);
return null;
}
//addEntry(0, null, value, 0);
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}
// 当然这里还进行可 扩容的操作，当当前元素size >= 增长位置threshold 的时候
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
// 这里我很意外，这里设置了一个最大初始化的位置，是Integer 最大值的一半
// 当元素刚好有MAXIMUM_CAPACITY这么多时，就一个赋值 return,后面就无法完成扩容了
// 而我们看到扩容是 都是2*table.length,而这个数是一个单数- -，那么这里理论上是无法
// 得到执行的。也就是没用的，谁知道 这里的设计是为了什么呢？
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 这里就是新的扩容了，
Entry[] newTable = new Entry[newCapacity];
// 这里就是数组的复制，并且位置是从新计算了的。感觉上是比较耗的，因为会从新计算存放 // 的位置,不是单纯的复制，关于位置的计算，下面继续。
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}这是 put 方法 里面的两个东西
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
// hash值算法，为了减小重复而这样方式的
// 这里先不谈，专门找章节介绍，可以参考：http://marystone.iteye.com/blog/709945
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
//参考：http://blog.youkuaiyun.com/heyutao007/article/details/6206153
static int indexFor(int h, int length) {
return h & (length-1);
}
// 通过相同的hash 和 indexFors 算法，快速的取值
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;
}
综上可以看看出：put 方法 是通过hash算法，以及indexFor 算出值应该存放在数组的哪个位置，并不是顺序存放的，这样的好处是 在取值的 也可以通过算法 就行读取。但是存放过程中进过了大量的计算，以及数组的操作，因此不难理解存放是比较耗时的，而取值是很快的。
下面我们来看看几个常用的方法：
remove():
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
// final 提高查找速度
final Entry<K,V> removeEntryForKey(Object key) {
// 通过hash 和 i, 找出table 中元素的位置
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;
// 通过该元素的hash 和 key 值，进行对比 确认元素
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
// 通过数组用后一个元素 覆盖当前元素，完成移除操作
// 这里size --,当时数组空间其实并没减少，只是最后一个元素你无法访问了
// 相当于 1,2,3,4,5 移除3， 就变成了1,2,4,5,5,但是size 5变成了4！
// 这里估计是想操作数组又需要时间 和空间吧！
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
下面来看我们常用的几个方法：
public Set<Map.Entry<K,V>> entrySet()；
public Collection<V> values()；
// 获得所有value 的集合
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();
}
// ..略
}
// 获得所有Entry的集合
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());
}
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
// ... 略
}
// 获得所有key的集合
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();
}
// ... 略
}
这里主要其实也差不多，
newKeyIterator 等3个方法
，继承的
HashIterator
private final class ValueIterator extends HashIterator<V> {
public V next() {
return nextEntry().value;
}
}
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();
}
} private abstract class HashIterator<E> implements Iterator<E> {
// 这里感觉和Entry 差不多，其实是的，这里内部类主要是为了维护table[Entry]
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) { // advance to first entry
Entry[] t = table;
// 这里其实是通过循环 对next 赋值，每次都取得第一个值，
// 这写法好真简洁！
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
// 这里就能获得entry,然后通过entry 就能获得需要的值了
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;
}
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;
}
}
小结 ：这里就介绍了 hashMap 的常用方法，总的来说和hashTable 实现的功能上差不多，但是细节上上的区别，比如：1.hashMap 没table 那线程安全锁，因此线程是不安全的，速度更快。2：hash 值上，hashMap 独立了hash算法，并且算法是通过key value 多次算出来的，减少了重复性。3：hashMap 可以放key 为null 的值，并且默认是数组第一个。4：设计上都是可以获得Set 集合，从而遍历集合，hashMap 是独立了内部类，分别获得key value entry,而hashTale 仅仅是3个变量去获得，hashMap 扩展性更好。当然还有其他的实现方式的区别，就不解释了，需要再慢慢研究。
hashMap 这里就结束了，希望大家多批评指定，小弟一定学习改正！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
