源码阅读之hashmap

Posted 2021-04-24 程序员食堂

面试中，我们经常会被面试官问到：有没有阅读过源码？

没有算法经验，

不懂设计模式

基础差，

底子薄，

的

你

到底源码该如何阅读呢？

那今天就带大家一行一行阅读hashmap的源码！

源码阅读-Hashmap(一)

一、JDK1.8的HashMap源码的改进

在JDK1.8之前，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。

而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

下图中代表JDK1.8之前的HashMap结构，左边部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中。（此图借用网上的图）

JDK1.8之前的HashMap都采用上图的结构，都是基于一个数组和多个单链表，hash值冲突的时候，就将对应节点以链表的形式存储。

如果在一个链表中查找其中一个节点时，将会花费O（n）的查找时间，会有很大的性能损失。

到了jdk1.8，当同一个hash值的节点数不小于8时，不再采用单链表形式存储，而是采用红黑树，如下图所示（此图是借用的图）

二、JDK1.8的HashMap源码分析

1

1.HashMap的继承关系

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

可以看到HashMap继承自父类AbstractMap，实现了Map、Cloneable、Serializable接口。

其中，Map接口定义了一组通用的操作；Cloneable接口则表示可以进行拷贝，在HashMap中，实现的是浅层次拷贝，即对拷贝对象的改变会影响被拷贝的对象；Serializable接口表示HashMap实现了序列化，即可以将HashMap对象保存至本地，之后可以恢复状态。

2

2.类的主要属性

//默认初始容量是16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

//默认最大的容量

static final int MAXIMUM_CAPACITY = 1 << 30;

//默认负载因子是0.75

static final float DEFAULT_LOAD_FACTOR = 0.75f;

//当桶上的结点数量大于等于8时底层结构由链表变为红黑树

static final int TREEIFY_THRESHOLD = 8;

//当桶上的结点数量小于等于6时等层结构由红黑树变为链表

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;

3 

3.类的重要构造函数

//指定初始容量和负载因子的构造函数

public HashMap(int initialCapacity, float loadFactor) {

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);

//初始容量大于最大容量，则最大容量为初始容量

if (initialCapacity > MAXIMUM_CAPACITY)

initialCapacity = MAXIMUM_CAPACITY;

if (loadFactor <= 0 || Float.isNaN(loadFactor))

throw new IllegalArgumentException("Illegal load factor: " +loadFactor);

//初始化负载因子

this.loadFactor = loadFactor;

//初始化临界值

//tableSizeFor(initialCapacity)返回大于等于initialCapacity的最小的二次幂数值。

this.threshold = tableSizeFor(initialCapacity);

//>>> 操作符表示无符号右移，高位取0。

static final int tableSizeFor(int cap) {

int n = cap - 1;

n |= n >>> 1;

n |= n >>> 2;

n |= n >>> 4;

n |= n >>> 8;

n |= n >>> 16;

return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

}

//指定初始容量的构造函数，采用默认的负载因子

public HashMap(int initialCapacity) {

this(initialCapacity, DEFAULT_LOAD_FACTOR);

}

//无参的构造函数，属性均采用默认值

public HashMap() {

this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted

}

//通过指定的Map集合构造一个HashMap

public HashMap(Map<? extends K, ? extends V> m) {

//采用默认的负载因子

this.loadFactor = DEFAULT_LOAD_FACTOR;

//将m的所有元素存入本HashMap实例中

putMapEntries(m, false);

}

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {

    int s = m.size();

    if (s > 0) {

        // 判断table是否已经初始化

        if (table == null) { // pre-size

            // 未初始化，s为m的实际元素个数

            float ft = ((float)s / loadFactor) + 1.0F;

            int t = ((ft < (float)MAXIMUM_CAPACITY) ?

                    (int)ft : MAXIMUM_CAPACITY);

            // 计算得到的t大于阈值，则初始化阈值

            if (t > threshold)

                threshold = tableSizeFor(t);

        }

        // 已初始化，并且m元素个数大于阈值，进行扩容处理

        else if (s > threshold)

            resize();

       

       // 将m中的所有元素添加至HashMap中

  for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {

            K key = e.getKey();

            V value = e.getValue();

            putVal(hash(key), key, value, false, evict);

        }

    }

}

今天先讲解一部分，不知道大家还有什么疑问呢？后续请关注明日推送

阅读源码

程序员食堂

查看: 13500 回复:135

一定要养成阅读优秀源码的习惯

只有这样子

你才可以

学习别人优秀的设计，

合理的抽象，

简洁的代码，