HashMap在java编程中，算使用频率top10中的类了。这里是关于HashMap的源码的分析。一个类的源码分析，要看他的来龙去脉，他的历史迭代。一来从以前的版本开始分析，由易到难；二来可以看到他的迭代优化过程。HashMap的源码分析，就从很老以前的一个版本开始分析。
简要说明，HashMap内部是一个数组，Object key 通过hash得到数组的index，如果数组index的位置有碰撞，则通过链表的形式接到那个位置上。取值是先hash到某个位置，然后在比较链表中每个值，获取到要取的值。
这里先重点分析java1.2中HashMap的源码。
private transient Entry table[];
private transient int count;
private int threshold;
private float loadFactor;
private transient int modCount = 0;
// 构造方法一
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Initial Capacity: "+
initialCapacity);
if (loadFactor <= 0)
throw new IllegalArgumentException("Illegal Load factor: "+
loadFactor);
if (initialCapacity==0)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry[initialCapacity];
threshold = (int)(initialCapacity * loadFactor);
}
// 构造方法二
public HashMap(int initialCapacity) {
this(initialCapacity, 0.75f);
}
// 构造方法三
public HashMap() {
this(101, 0.75f);
}
// 构造方法四
public HashMap(Map t) {
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}
属性数组table就是HashMap内部存放各种实体的数组。
count是当前存放实体的数量。
modCount是HashMap修改的次数，这里不是做什么统计用，在后面的HashIterator里要用到，HashIterator计算中，不希望HashMap被修改的。
initialCapacity是HashMap内数组的初始长度。构造方法三中，默认初始长度为101，不太清楚这个101是怎么定义出来的。在构造方法四中，他的初始长度是11和入参map长度的2倍之间的大值。这里的11和101比较诡异。
capacity是HashMap里数组的最大长度，随着HashMap里数组长度的变化而变化。
threshold是用来提醒数组table该增大了的一个阀值。
loadFactor是threshold值计算的一个系数，默认0.75， threshold ＝ capacity * loadFactor 。
基本的方法：
// 查看HashMap存放数，count是HashMap的存放数属性
public int size() {
return count;
}
// 查看HashMap存放数是否为空，count＝=0表示存放数为空
public boolean isEmpty() {
return count == 0;
}
对于调用方存入的一个个key和value，HashMap内部存放的是一个个内部实体对象，这里分析他的内部实体类。
// HashMap内部实体类
private static class Entry implements Map.Entry {
int hash; // 存入HashMap key值的hashCode值
Object key; // 存入HashMap的key值
Object value; // 存入HashMap的value值
Entry next; // 存入HashMap中下一个值，这里是为产生Hash碰撞后，链表结构准备的，单向链表
// 构造方法
Entry(int hash, Object key, Object value, Entry next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
// 对象克隆方法
protected Object clone() {
return new Entry(hash, key, value,
(next==null ? null : (Entry)next.clone()));
}
public Object getKey() {
return key;
}
public Object getValue() {
return value;
}
// 设置value值，并返回老的value值
public Object setValue(Object value) {
Object oldValue = this.value;
this.value = value;
return oldValue;
}
// 判断实体对象的相等方法；只有在实体的key和value都相等时，才相等
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
(value==null ? e.getValue()==null : value.equals(e.getValue()));
}
// hashCode值，实体的hashCode值为key的hashCode和value的hashCode的异或值
public int hashCode() {
return hash ^ (value==null ? 0 : value.hashCode());
}
public String toString() {
return key+"="+value;
}
}
HashMap同时也实现了Iterator接口，这里分析他的实现逻辑
// Iterator的类型
private static final int KEYS = 0; // Iterator对key进行操作
private static final int VALUES = 1;// Iterator对value进行操作
private static final int ENTRIES = 2;// iterator对entry进行操作
// HashMap对Iterator接口的实现
private class HashIterator implements Iterator {
Entry[] table = HashMap.this.table;
int index = table.length;
Entry entry = null; // 临时变量，存放hasNext方法时，遍历到的数组位链表对象
Entry lastReturned = null; // 临时变量，存放next方法时，遍历到的对象；为remove方法中准备
int type; // iterator的类型
// 存放HashMap修改的次数
private int expectedModCount = modCount;
// 构造方法，入参为设定Iterator的类型
HashIterator(int type) {
this.type = type;
}
// 判断容器内是否有值
public boolean hasNext() {
while (entry==null && index>0)
entry = table[--index];
return entry != null;
}
// 获取下一个值
public Object next() {
// 遍历过程中，HashMap是不允许有改动，否则抛出异常ConcurrentModificationException
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
// 遍历过程中，处理那种没有先调用hasNext方法的情况
while (entry==null && index>0)
entry = table[--index];
// 如果entry不为null，处理entry
if (entry != null) {
// entry存放在临时变量lastReturned
Entry e = lastReturned = entry;
// entry存放链表的下一个节点，为下一次调用next方法做准备
entry = e.next;
// 根据type的类型，返回不同的值
return type == KEYS ? e.key : (type == VALUES ? e.value : e);
}
throw new NoSuchElementException();
}
// 移除实体对象
public void remove() {
// remove调用之前，需要先调用hasNext方法，否则lastReturned=null,抛出异常
if (lastReturned == null)
throw new IllegalStateException();
// 移除操作，HashMap也不希望在其他地方有修改
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry[] tab = HashMap.this.table;
// 找到lastReturned对应数组的位置
int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;
// 找到对应数组的位置后，删除对应链表中的lastReturned值，下面是链表的操作
for (Entry e = tab[index], prev = null; e != null;
prev = e, e = e.next) {
if (e == lastReturned) {
modCount++;
expectedModCount++;
if (prev == null)
tab[index] = e.next;
else
prev.next = e.next;
count--;
lastReturned = null;
return;
}
}
throw new ConcurrentModificationException();
}
}
下面主要分析HashMap的添删查
// 判断HashMap是否包含key值
public boolean containsKey(Object key) {
Entry tab[] = table;
// key值不为null
if (key != null) {
// 通过key计算出key对应数组table的下标，其实这里是可以封装成一个方法的，多个地方都要用到，后面jdk的版本都有改进
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
// 查找链表，判断key是否存在
for (Entry e = tab[index]; e != null; e = e.next)
if (e.hash==hash && key.equals(e.key))
return true;
} else { // key为null
// 查找链表，判断key是否存在
for (Entry e = tab[0]; e != null; e = e.next)
if (e.key==null)
return true;
}
return false;
}
// 判断HashMap是否包含value值
// 这个方法实际效率是很低的，需要先遍历数组，在一个个遍历链表，没有用到hash特性
public boolean containsValue(Object value) {
Entry tab[] = table;
// value值为null
if (value==null) {
// 遍历数组
for (int i = tab.length ; i-- > 0 ;)
// 遍历链表
for (Entry e = tab[i] ; e != null ; e = e.next)
if (e.value==null)
return true;
} else {// value值不为null
// 遍历数组
for (int i = tab.length ; i-- > 0 ;)
// 遍历链表
for (Entry e = tab[i] ; e != null ; e = e.next)
if (value.equals(e.value))
return true;
}
return false;
}
// 获取key对应的value值
public Object get(Object key) {
Entry tab[] = table;
// key不为null
if (key != null) {
// key的hashCode值
int hash = key.hashCode();
// key的hashCode计算出的hash值
int index = (hash & 0x7FFFFFFF) % tab.length;
// 通过index定位到数组，然后遍历对应的链表结构
for (Entry e = tab[index]; e != null; e = e.next)
if ((e.hash == hash) && key.equals(e.key))
return e.value;
} else {
// 如果key为null，直接遍历对应的链表结构
for (Entry e = tab[0]; e != null; e = e.next)
if (e.key==null)
return e.value;
}
return null;
}
// 往HashMap中存放key和value
public Object put(Object key, Object value) {
Entry tab[] = table;
int hash = 0;
int index = 0;
// 这部分操作是当数组下标的对应位置已经有值，并且
// key不为null
if (key != null) {
// 获得key对应数组的下标
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
// 在数组对应的下标有值的情况下
// key已经存在，把新的value代替老的value，并返回老的value
for (Entry e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && key.equals(e.key)) {
Object old = e.value;
e.value = value;
return old;
}
}
} else { // key为null，数组的下标是确定的，为0
// 在数组对应的下标有值的情况下
// key已经存在，把新的value代替老的value，并返回老的value
for (Entry e = tab[0] ; e != null ; e = e.next) {
if (e.key == null) {
Object old = e.value;
e.value = value;
return old;
}
}
}
// HashMap的修改次数加一
modCount++;
// 如果数组的使用长度大于或等于阀值threshold后
if (count >= threshold) {
// 扩展数组
rehash();
// 重新赋值tab
tab = table;
// 重新计算index
index = (hash & 0x7FFFFFFF) % tab.length;
}
// 在原HashMap中，key没找到对应的value时
// 这里先构造一个实体，把实体的next属性指向数组下标index对应的位置
Entry e = new Entry(hash, key, value, tab[index]);
// 数组下标对应的位置赋值实体e
tab[index] = e;
// 实体数量加一
count++;
return null;
}
// 推展数组
private void rehash() {
// 原数组长度
int oldCapacity = table.length;
// 原数组
Entry oldMap[] = table;
// 新数组长度，这里数组的增长策略是2倍加一的增
int newCapacity = oldCapacity * 2 + 1;
// 重新创建数组
Entry newMap[] = new Entry[newCapacity];
// HashMap的修改次数加一
modCount++;
// 更新HashMap的扩展数组的阀值
threshold = (int)(newCapacity * loadFactor);
// 赋值新数组到HashMap的数组
// 这个地方存在并发问题，因为此时数组虽然创建了，但是实体值还是没有迁移过来的。
// 如果此时有人读取value值，可能会返回为空
table = newMap;
// 把老数组里的值迁移到新数组里
// 遍历数组
for (int i = oldCapacity ; i-- > 0 ;) {
// 遍历链表
for (Entry old = oldMap[i] ; old != null ; ) {
Entry e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = newMap[index];
newMap[index] = e;
}
}
}
// 移除实体
public Object remove(Object key) {
Entry tab[] = table;
// key不为null
if (key != null) {
// 获得key对应的hash值和对应的数组下标
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
// 根据对应的数组下标，找到链表对象
// 遍历链表
for (Entry e = tab[index], prev = null; e != null;
prev = e, e = e.next) {
if ((e.hash == hash) && key.equals(e.key)) {
modCount++;
if (prev != null)
prev.next = e.next;
else
tab[index] = e.next;
count--;
Object oldValue = e.value;
e.value = null;
return oldValue;
}
}
} else {// key为null，对应的数组下标为0
// 根据对应的数组下标，找到链表对象
// 遍历链表
for (Entry e = tab[0], prev = null; e != null;
prev = e, e = e.next) {
if (e.key == null) {
modCount++;
if (prev != null)
prev.next = e.next;
else
tab[0] = e.next;
count--;
Object oldValue = e.value;
e.value = null;
return oldValue;
}
}
}
return null;
}
// 批量添加
public void putAll(Map t) {
Iterator i = t.entrySet().iterator();
while (i.hasNext()) {
Map.Entry e = (Map.Entry) i.next();
put(e.getKey(), e.getValue());
}
}
// 清除数组内容
public void clear() {
Entry tab[] = table;
modCount++;
for (int index = tab.length; --index >= 0; )
tab[index] = null;
count = 0;
}
时间： 2024-11-01 13:06:38