HashMap源码阅读学习

转载至 JavaGuide

什么是HashMap

HashMap主要是用来存放键值对的,它基于哈希表的Map接口实现,是java最常用的集合之一。

JDK1.8之前HashMap是由 数组+链表 组成的,HashMap中封装了一个数组,数组是HashMap的主体,链表是主要为了解决哈希冲突而存在的(”拉链法”解决冲突).JDK1.8以后再解决hash冲突的时有了较大改进,当链表长度大于默认的阀值‘8’时,将链表转化为红黑树,以减少搜索时间。

底层数据结构的区别

jdk1.8之前

HashMap底层是 数组和链表 结合在一起使用的,也就是链表散列。HashMap通过key的 hashCode 经过扰动函数处理后得到的hash值,然后通过 (n-1) & hash 判断当前元素的存放位置(这里n为数组的长度),如果当前位置存在元素的话,就判断改元素与要存入元素的hash值以及key是否相同,如果相同的话,直接覆盖,不相同就通过拉链法解决冲突。

所谓 扰动函数 指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。

所谓 拉链法 就是:将链表和数组结合。也就是说创建一个链表数组,数组中每一格就是一个链表。若遇到hash冲突,则将冲突的值添加到链表当中。

JDK 1.8 HashMap 的 hash 方法源码:

JDK 1.8 的 hash方法 相比于 JDK 1.7 hash 方法更加简化,但是原理不变。

1
2
3
4
5
6
7
static final int hash(Object key) {
int h;
// key.hashCode():返回散列值也就是hashcode
// ^ :按位异或
// >>>:无符号右移,忽略符号位,空位都以0补齐
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

JDK1.7的 HashMap 的 hash 方法源码

1
2
3
4
5
6
7
8
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);
}

jdk1.8之后

相较于之前的版本,JDK1.8在解决hash冲突时有了较大变化,当链表长度大于等于阀值(默认为8)时,将链表转化为红黑树,以减少搜索时间。

类的属性:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
// 序列号
private static final long serialVersionUID = 362498820763181265L;
// 默认的初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 当桶(bucket)上的结点数大于这个值时会转成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 当桶(bucket)上的结点数小于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;
// 桶中结构转化为红黑树对应的table的最小大小
static final int MIN_TREEIFY_CAPACITY = 64;
// 存储元素的数组,总是2的幂次倍
transient Node<k,v>[] table;
// 存放具体元素的集
transient Set<map.entry<k,v>> entrySet;
// 存放元素的个数,注意这个不等于数组的长度。
transient int size;
// 每次扩容和更改map结构的计数器
transient int modCount;
// 临界值 当实际大小(容量*填充因子)超过临界值时,会进行扩容
int threshold;
// 填充因子
final float loadFactor;
}
  • loadFactor加载因子

    loadFactor加载因子是控制数组存放数据的疏密程度,loadFactor越接近为1,那么Map中存放的数据(Entry)也就越多,同时链表的长度也会增加,loadFactor越小,密度越低,数据存放少。

    loadFactor太大会导致查找效率低,太小导致数组的使用率低,存放的数据很分散,loadFactor的默认值为0.75f是官方提供的比较的一个临界值。

  • threshold 译为阀值

    threshuld = capacity(容量)*loadFactor,当 size >= threshould 时就会触发对数组的扩容,这个属性就是衡量Map内数组是否需要扩容的一个标准。

  • Node节点类源码:*

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    // 继承自 Map.Entry
    static class Node implements Map.Entry<K,V> {
    final int hash;// 哈希值,存放元素到hashmap中时用来与其他元素hash值比较
    final K key;//键
    V value;//值
    // 指向下一个节点
    Node<K,V> next;
    Node(int hash, K key, V value, Node<K,V> next) {
    this.hash = hash;
    this.key = key;
    this.value = value;
    this.next = next;
    }
    public final K getKey() { return key; }
    public final V getValue() { return value; }
    public final String toString() { return key + "=" + value; }
    // 重写hashCode()方法
    public final int hashCode() {
    return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

    public final V setValue(V newValue) {
    V oldValue = value;
    value = newValue;
    return oldValue;
    }
    // 重写 equals() 方法
    public final boolean equals(Object o) {
    if (o == this)
    return true;
    if (o instanceof Map.Entry) {
    Map.Entry e = (Map.Entry)o;
    if (Objects.equals(key, e.getKey()) &&
    Objects.equals(value, e.getValue()))
    return true;
    }
    return false;
    }
    }
  • 树节点类源码:*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static final class TreeNode extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // 父
TreeNode<K,V> left; // 左
TreeNode<K,V> right; // 右
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red; // 判断颜色
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
// 返回根节点
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
}