HashMap在开发中经常用,面试源码方面也会经常问到,在之前也多次了解过源码,今天算是复习一下,顺便好好总结一下,包括在后面有相关面试题。本文不会对红黑树代码由太多深入研究,特别是删除方面太复杂,面试也不会问到,知道红黑树基本实现原理就可以了

  源码基于jdk1.8,我们都知道1.8版本的HashMap有很大改变,通过数组+链表+红黑树实现

图例:

关于链表和红黑树相关内容,可以参考:

Java数据结构和算法(四)--链表

Java数据结构和算法(八)--红黑树与2-3树

基本结构:

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable { private static final long serialVersionUID = 362498820763181265L;
}

继承了AbstractMap,有实现了Map,这里算是jdk 集合开发者的一个失误吧,后来证明这样写没什么卵用,只是一直没改,保留下来了。实现Cloneable和Serializable接口,可以实现clone、序列化以及反序列化

成员变量:

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默认初始容量16,容量一定是2的次幂

static final int MAXIMUM_CAPACITY = 1 << 30;	//最大容量

static final float DEFAULT_LOAD_FACTOR = 0.75f;	//默认加载因子

static final int TREEIFY_THRESHOLD = 8;	//树形化阀值,也就是当链表的节点个数大于等于这个值时,会将链表转化为红黑树

static final int UNTREEIFY_THRESHOLD = 6;	//解除树形化阀值,也就是当链表的节点个数小于等于这个值时,会将红黑树转换成普通的链表

//树形化的另一条件Map数组的长度阈值64。当数组的长度小于这个值时,就算树形化阈达标,链表也不会转化为红黑树,而是优先扩容数组resize()
static final int MIN_TREEIFY_CAPACITY = 64; transient Node<K,V>[] table; //保存元素的内部数组 transient Set<Map.Entry<K,V>> entrySet; //保存Entry的set transient int size; //当前存储的键值对的数量 transient int modCount; //集合被修改的次数,用于迭代器的快速失败 int threshold; //阀值=Capacity*loadFactor final float loadFactor; //加载因子

构造方法:

public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0) //初始容量<0,抛出异常
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY) //初始容量 > MAXIMUM_CAPACITY,赋值为MAXIMUM_CAPACITY
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor)) //初始容量<0,或者不是数字,抛出异常
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity); //初始容量,返回的是initialCapacity的最小二次幂
}

tableSizeFor():

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;
}

>>>无符号右移,高位补0,最终返回最小二次幂,例如:cap=13,返回16,cap=17,返回32,因为容量要求为2的次幂

Node:

static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //key的hash值
final K key;
V value;
Node<K,V> next; //next node 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; } public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
} public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
} 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;
}
}

Node为HashMap的内部类,就是单向链表,比较简单

TreeNode为红黑树的实现,看看就行,容易看的脑仁疼

put():

public V put(K key, V value) {
return putVal(hash(key), key, value, false, true); //调用putVal()
} //onlyIfAbsent为false,可以update oldValue,为true,不会update
//evict为false,处于创建模式,HashMap中不起作用,在LinkedHashMap有作用
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0) //如果当前数组为null,或者数组的length为0,进行扩容(有初始化的作用)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) //(n-1)&hash就是寻址,找到key对应的下标,对应位置如果没有数据,直接生成一个新的节点
tab[i] = newNode(hash, key, value, null);
else { //否则对应下标有值
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //key对应位置的首节点和key相同,直接覆盖value
e = p;
else if (p instanceof TreeNode) //如果首节点是红黑树
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { //首节点为链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) { //新生成一个节点,添加到链表尾部
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) //如果>=8-1,尝试进行树形化
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; //
}
}
if (e != null) { //覆盖oldValue
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount; //修改次数+1
if (++size > threshold) //如果元素个数大于阈值,进行扩容
resize();
afterNodeInsertion(evict);
return null;
}

添加/修改流程:

1、判断数据是否为空,如果为null,通过resize()进行初始化

2、如果key对应位置为null,直接生成节点,假如数组对应位置

3、否则就是可以对应位置有值

  3.1).变量p为key对应位置节点,如果直接和key相等,也就是这个node只是一个节点,不是链表或者红黑树,直接通过变量e保存p

  3.2).如果p instanceof 为红黑树,添加到红黑树

  3.3).如果p为链表,循环链表是否有对应key,true先保存下来,false,key对应节点添加到尾部,并判断链表长度是否 >

TREEIFY_THRESHOLD - 1 = 7,true,尝试进行树形化

final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) //判断数组长度与MIN_TREEIFY_CAPACITY,不大于64的情况下,进行扩容,而不是树形化
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) { //树形化的具体步骤
TreeNode<K,V> hd = null, tl = null;
//省略后面代码
}
}

4、覆盖oldValue

5、判断是否扩容

resize():

final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {//oldCapacity > MAXIMUM_CAPACITY,赋值Integer.MAX_VALUE,直接返回
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY) //否则扩容为oldThreshold的2倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) //oldCap = 0,oldThr > 0,将oldThr赋值给newCap
newCap = oldThr;
else { //oldCap = 0,oldThr = 0,进行初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr; //新的阈值
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; //生成一个新的数组
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { //如果对应下标有值
oldTab[j] = null; //oldTab对应下标设置为null,便于GC
if (e.next == null) //如果对应下标位置只是数组,赋值到新数组
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) //如果对应下标位置为红黑树
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { //如果对应下标位置为链表
Node<K,V> loHead = null, loTail = null; //需要存放到原来的位置
Node<K,V> hiHead = null, hiTail = null; //需要存放到原来的位置 + oldCap
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) { //hash对应oldCap的bit为0
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else { //hash对应oldCap的bit为1
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) { //hash对应oldCap的bit为0的key放到原位
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) { //hash对应oldCap的bit为1的key放到原位 + oldCap
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}

resize()在jdk1.8和之前版本的区别:

举例:oldCapacity=8,之前hash等于3,11,19,27的key,index都是3

  jdk1.7的resize(),需要重新对地址重新寻址,扩容之后Capacity=16,index分别为3,11,3,11,但是有一点是会把之前index的数据先添加到链表的尾部,再把链表添加到对应数组位置,所以会导致同一位置的数据发生倒置,代码如下

int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;

  而jdk1.8不需要进行重新hash,上述四个key,通过hash&oldCapacity分别得到:0,8,0,8,结果为0的,保存到原index,其他保存在原index + oldCapacity,而且hash冲突的数据扩容之后不会倒置

总结:是否rehash、hash冲突的数据顺序是两个版本的主要区别

PS:原数组如果存在null,扩容之后null仍然存在

remove():

public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) { //hash对应位置的数据不为null
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //如果对应下标位置只是数组
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode) //如果对应下标位置为红黑树
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else { //如果对应下标位置为链表
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) { //对应这三种情况,分别删除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}

get():

public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}

也没啥好说的,也是三种情况下(数组、红黑树、链表)的搜索

遍历:

public static void main(String[] args) throws IOException {
HashMap<Integer,String> map = new HashMap(4);
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
map.put(4, "d");
map.keySet().forEach((key) -> {
System.out.println(key + " " + map.get(key));
});
map.values().forEach((value) -> {
System.out.println(value);
});
Set<Map.Entry<Integer,String>> entry = map.entrySet();
entry.forEach((entry1) -> {
System.out.println(entry1.getKey() + " " + entry1.getValue());
});
Iterator<Map.Entry<Integer,String>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<Integer,String> mapEntry = iterator.next();
System.out.println(mapEntry.getKey() + " " + mapEntry.getValue());
}
}

如果只是获取key/value,可以使用keySet()和values()

否则建议使用后两种

面试题:

1、为什么HashMap的Capacity要保持2的次幂?

1).因为HashMap寻址通过(length - 1) & hash,如果length不是2的次幂,例如10,通过前面的表达式,很多位置永远不可能被使用,例如0001,0100等。也就不能通过(length - 1) & hash来实现取模,位运算的效率是远远高于取余%运算的。包括resize()操作等,这些实现都需要修改。

2).如果不是这样计算下标位置的方法不能通过(length - 1) & hash实现,因为[]table有些位置永远不可能被占用,从而造成浪费,感兴趣的,可以试试。所以HashMap通过tableSizeFor()来保证Capacity一定是2的次幂

2、jdk1.8和之前版本对于HashMap实现的区别?

1、取消了成员变量Capacity,保存到threshold

2、链表和红黑树的转化,有两个条件,链表到红黑树的查询效率:从O(N)变成O(logn)

3、扩容resize()实现不同

4、hash()实现不同

3、HashMap的Node[]序列化

和其他集合的实现相同,都是通过重写writeObject()和readObject()实现自定义序列化,把Node[]通过transient修饰。

4、HashMap的table为什么是transient的

  因为HashMap是基于HashCode的,HashCode作为Object的方法,是native的

  这意味着HashCode和底层实现相关,不同的虚拟机可能有不同的HashCode算法。再进一步说得明白些就是,可能同一个Key在虚拟机A上的HashCode=1,在虚拟机B上的HashCode=2,在虚拟机C上的HashCode=3。

  所以自己通过writeObject()达到序列化的目的。

5、hashmap和hashtable区别:

  1、HashMap的初始容量为16,扩容为2倍,Hashtable初始容量为11,扩容为2倍+1,两者的填充因子默认都是0.75

  2、HashMap和Hashtable的底层实现都是数组+链表结构实现

  3、两者计算hash的方法不同

  4、hashtable的key和value都不能为null,而hashmap都可以

  5、hashtable线程安全,hashmap线程不安全

6、HashMap的key和value能为null吗?

key和value都可以为null,但是只能保存一个。key为null的元素保存在数组的下标0位置

发生扩容null照样存在

HashMap<Integer,String> map = new HashMap(4);
map.put(null, null);
map.put(null, null);
map.put(2, "b");
map.put(3, "c");
map.put(4, "d");
map.put(5, "d");
Set<Map.Entry<Integer,String>> entry = map.entrySet();
entry.forEach((entry1) -> {
System.out.println(entry1.getKey() + " " + entry1.getValue());
});
输出结果:
null null
2 b
3 c
4 d
5 d

内容参考:一文搞定HashMap的实现原理和面试 - 掘金

Java集合(七)--基于jdk1.8的HashMap源码的更多相关文章

  1. Java集合(四)--基于JDK1.8的ArrayList源码解读

    public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess ...

  2. 基于jdk1.8的HashMap源码学习笔记

    作为一种最为常用的容器,同时也是效率比较高的容器,HashMap当之无愧.所以自己这次jdk源码学习,就从HashMap开始吧,当然水平有限,有不正确的地方,欢迎指正,促进共同学习进步,就是喜欢程序员 ...

  3. Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例

    概要 前一章,我们学习了HashMap.这一章,我们对Hashtable进行学习.我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Hashtable.第1部分 Ha ...

  4. 【转】Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例

    概要 前一章,我们学习了HashMap.这一章,我们对Hashtable进行学习.我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Hashtable.第1部分 Ha ...

  5. Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例

    概要  前面,我们已经学习了ArrayList,并了解了fail-fast机制.这一章我们接着学习List的实现类——LinkedList.和学习ArrayList一样,接下来呢,我们先对Linked ...

  6. Java 集合系列07之 Stack详细介绍(源码解析)和使用示例

    概要 学完Vector了之后,接下来我们开始学习Stack.Stack很简单,它继承于Vector.学习方式还是和之前一样,先对Stack有个整体认识,然后再学习它的源码:最后再通过实例来学会使用它. ...

  7. 【转】 Java 集合系列07之 Stack详细介绍(源码解析)和使用示例

    概要 学完Vector了之后,接下来我们开始学习Stack.Stack很简单,它继承于Vector.学习方式还是和之前一样,先对Stack有个整体认识,然后再学习它的源码:最后再通过实例来学会使用它. ...

  8. Java -- 基于JDK1.8的ThreadLocal源码分析

    1,最近在做一个需求的时候需要对外部暴露一个值得应用  ,一般来说直接写个单例,将这个成员变量的值暴露出去就ok了,但是当时突然灵机一动(现在回想是个多余的想法),想到handle源码里面有使用过Th ...

  9. [Java] 集合框架原理之一:基本结构与源码分析

    一.Collection Collection 接口定义了一些基本的方法: int size(); boolean isEmpty(); boolean add(E e); boolean addAl ...

随机推荐

  1. [JZOJ3171] 【GDOI2013模拟4】重心

    题目 描述 题目大意 有一堆长为222的矩形,最下面的右端点横坐标为000. 每个矩形都有其固定的质量. 将这些矩形堆在一起,使得最右边的横坐标最大,并且满足它不会塌掉(满足物理学). 思考历程 首先 ...

  2. 【转载】linux进程及进程控制

    Linux进程控制   程序是一组可执行的静态指令集,而进程(process)是一个执行中的程序实例.利用分时技术,在Linux操作系统上同时可以运行多个进程.分时技术的基本原理是把CPU的运行时间划 ...

  3. Django + Uwsgi + Nginx 的生产环境部署实战

    目录 Django + Uwsgi + Nginx 的生产环境部署实战 安装Uwsgi 一.使用命令来启动django项目 二.使用配置文件来启动我们的Django项目 安装Nginx 配置Nginx ...

  4. Cannot find module '@babel/plugin-proposal-class-properties'

    cnpm install --save-dev @babel/plugin-proposal-class-properties

  5. 修改数组中对象的key值

    遇见场景:echart图表中后台返回我的数据,后台无法修改key值,但是echart渲染图表的时候,需要用 var m2R2Data= [ {value:335,name:"种类01 335 ...

  6. HTTP的九种请求方法

    HTTP1.0定义了三种请求方法:GET.POST.HEAD HTTP1.1定义了六种请求方法:PUT.DELETE.PATCH.OPTIONS.CONNECT.TRACE 1.get 请求指定页面的 ...

  7. Android HttpClient 用法以及乱码解决

    一.Post提交 并可以实现多文件上传 // 创建DefaultHttpClient对象 HttpClient httpclient = new DefaultHttpClient(); // 创建一 ...

  8. jeecms 代码生成 Tools

    本文作者: IIsKei 本文链接: http://www.iskei.cn/posts/50510.html 版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议 ...

  9. ORC格式hive逻辑中case when问题

    前阵子做hive开发发现orc格式文件使用case when情况下会造成nullcount会统计入内问题,修改为sum就没此问题.具体例子下次放假回来记录,现在不在公司,这里做个mark

  10. hdfs写并发问题

    hdfs文件写入不支持多个进程同时写入一个文件,每次只能一个FS挟持对象的人写入