java集合框架(一):HashMap
有大半年没有写博客了,虽然一直有在看书学习,但现在回过来看读书基本都是一种知识“输入”,很多时候是水过无痕。而知识的“输出”会逼着自己去找出没有掌握或者了解不深刻的东西,你要把一个知识点表达出来,自己没有吃透是很难写出来的。我算是明白了为什么有些人可以通过写博客来学习,我也不能懒了,坚持写下去。
都以为自己对java的集合框架掌握得还可以,打开源码才发现我只是掌握了他们的基本使用,而对原理和数据结构方面只是略知一二。接下来的一段时间里,我会写一个专题详细总结java集合框架知识,首先从HashMap开始吧。
HashMap是以Key-Value方式存储数据,Key用散列函数映射到table数组(散列表),解决冲突的方法是分离链接法。即HashMap的数据结构是:数组+链表+红黑树(java8增加了红黑树),其结构图如下:
一、类的定义
HashMap继承抽象类AbstractMap,实现了Map接口。抽象类AbstractMap实现了接口Map的部分方法,这样子类就可以通过继承而共用这些方法,而无须再次实现了。
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
二、存储结构
从上面的分析,我们知道HashMap的基本存储单元是Node<K,V>,它保存一个Key-Value。每个Node通过哈希函数映射到哈希桶数组,在源码中用Node<K,V>[] table表示哈希桶数组。下面来看看Node的源码(本文源码都是基于java8):
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //用来定位数组索引位置
final K key;
V value;
Node<K,V> next; //链表的下一个node Node(int hash, K key, V value, Node<K,V> next) { ... }
public final K getKey(){ ... }
public final V getValue() { ... }
public final String toString() { ... }
public final int hashCode() { ... }
public final V setValue(V newValue) { ... }
public final boolean equals(Object o) { ... }
}
三、构造函数
构造函数需要对下面几个参数初始化(部分使用默认的)
Node<K,V>[] table; // 哈希桶数组
int threshold;// 所能容纳的key-value对极限,大于这个阀值将会进行扩容
final float loadFactor; // 负载因子
int modCount; // 记录修改的次数
int size; // key-value对的个数
1.无参构造器
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 初始化默认负载因子为0.75
}
负载因子决定哈希桶数组的疏密程度,太疏会造成空间浪费,太密容易形成哈希冲突,一般使用默认的。
2.指定哈希桶数组初始容量构造器
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);// 调用两个参数的构造器
}
3.指定哈希桶数组初始容量和负载因子构造器
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 小于0或者不是数字时抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);//确保阀值为大于给定初始容量的最小2的n次幂,比如给定初始容量为9,则阀值为16(2的4次幂),给定为25,则为32(2的5次幂)
}
四、存储实现
1.put方法
public V put(K key, V value) {
// 对key的hashCode()做hash
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// tab为空则创建
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 通过hash计算数组index,如果index位置没有元素则直接插入Node对象
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// index对应位置已经有元素了,说明hash碰撞了,则需要构建链表或者红黑树
else {
Node<K,V> e; K k;
// hash和key都相等,可以当成是同一个对象,这时要么覆盖原来的value,要么继续使用原来的value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// index位置已经有红黑树了,加入新的节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 在index位置构建链表
else {
// 遍历链表,把新的节点加入到表尾部
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 当链表长度大于等于8时,转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 链表中有相同的hash和key,退出遍历
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 链表或者红黑树中存在相同的key,判断要不要覆盖
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 该函数提供给LinkedHashMap使用,维护了一个访问链表
afterNodeAccess(e);
return oldValue;
}
}
// 修改数加1,为多线程遍历提供fast-fail机制
++modCount;
// 判断是否需要扩容
if (++size > threshold)
resize();
// 该函数提供给LinkedHashMap使用,维护了一个插入顺序的双向链表
afterNodeInsertion(evict);
return null;
}
2.get方法
get操作其实就是通过哈希值算出节点所在table数组的位置,然后判断是链表还是红黑树或者是刚好是要找的值
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
} // 这纯粹是一个数学方法,>>>表示符号向右移动,假如有符号位-8表示为11000,则-8 >>> 2 == 5,把符号位也当成了数值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
} final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 通过hash值计算index位置
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;
}
五、遍历实现
遍历操作在内部抽象类HashIterator中实现,其实也是通过迭代器完成的,使用fast-fail机制保证遍历时map不会改变。遍历的迭代器会继承HashIterator。
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
} abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
// 初始化参数
HashIterator() {
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = 0;
// index从第一个不为null的地方开始
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
} public final boolean hasNext() {
return next != null;
}
// 这个方法会被迭代器next()方法调用
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
// fast-fail判断,避免遍历的时候map有发生改变
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
// 判读当前index位置是否还有下一个节点,就把下一个节点放到next,否则遍历table数组
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
}
六、java8的扩容机制
java8的扩容是做了优化的,直接看代码吧
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) {
// 当容量大于(1 << 30== 1073741824),让阈值等于最大整数,不再扩容,就让它碰撞吧
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 阈值扩大为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 有初始化阈值则新容量等于阈值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 使用默认的阈值和容量
else { // zero initial threshold signifies using defaults
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) {
// 遍历旧table数组的元素到新的table数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 在j处只有一个节点
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 在j处是红黑树
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 这里用了比较巧妙的方法,如果元素的hash值跟旧table数组的容量做按位与操作等于0,
// 则在新table数组中元素还是映射到相同的index位置。
// 否则映射到j+oldCap位置。这样一来就不用重新计算每个节点的位置了,在java6,java7中需要rehash到新的位置。
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 这里构造一个链表
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
七、总结
至此总算把HashMap的基本原理搞清楚了,通过源码我们对HashMap可以总结出以下几点:
- 哈希桶的默认初始容量为16,最大为1<<30 = 1073741824,当大于这个值时不再扩容。
- 如果可以预先知道存储元素的数量,最好在初始化HashMap的时候指定初始容量,这样就可以避免扩容带来的性能消耗。
- Java8对HashMap做了优化,增加了红黑树,如果hash碰撞较多时,其搜索性能明显优于链表。
参考资料:
Importnew:http://www.importnew.com/20386.html
博客园:http://www.cnblogs.com/chenssy/p/3521565.html
java集合框架(一):HashMap的更多相关文章
- Java集合框架:HashMap
转载: Java集合框架:HashMap Java集合框架概述 Java集合框架无论是在工作.学习.面试中都会经常涉及到,相信各位也并不陌生,其强大也不用多说,博主最近翻阅java集合框架的源码以 ...
- Java集合框架之HashMap浅析
Java集合框架之HashMap浅析 一.HashMap综述: 1.1.HashMap概述 位于java.util包下的HashMap是Java集合框架的重要成员,它在jdk1.8中定义如下: pub ...
- (转)Java集合框架:HashMap
来源:朱小厮 链接:http://blog.csdn.net/u013256816/article/details/50912762 Java集合框架概述 Java集合框架无论是在工作.学习.面试中都 ...
- Java 集合框架:HashMap
原文出处:Java8 系列之重新认识 HashMap 摘要 HashMap 是 Java 程序员使用频率最高的用于映射 (键值对) 处理的数据类型.随着 JDK(Java Developmet Kit ...
- java集合框架之HashMap
参考http://how2j.cn/k/collection/collection-hashmap/365.html#nowhere HashMap的键值对 HashMap储存数据的方式是-- 键值对 ...
- java集合框架之HashMap和Hashtable的区别
参考http://how2j.cn/k/collection/collection-hashmap-vs-hashtable/692.html#nowhere HashMap和Hashtable的区别 ...
- Java集合框架(四)-HashMap
1.HashMap特点 存放的元素都是键值对(key-value),key是唯一的,value是可以重复的 存放的元素也不保证添加的顺序,即是无序的 存放的元素的键可以为null,但是只能有一个key ...
- 深入理解java集合框架之---------HashMap集合
深入理解HaspMap死循环问题 由于在公司项目中偶尔会遇到HashMap死循环造成CPU100%,重启后问题消失,隔一段时间又会反复出现.今天在这里来仔细剖析下多线程情况下HashMap所带来的问题 ...
- Java集合框架系列大纲
###Java集合框架之简述 Java集合框架之Collection Java集合框架之Iterator Java集合框架之HashSet Java集合框架之TreeSet Java集合框架之Link ...
- java集合框架之java HashMap代码解析
java集合框架之java HashMap代码解析 文章Java集合框架综述后,具体集合类的代码,首先以既熟悉又陌生的HashMap开始. 源自http://www.codeceo.com/arti ...
随机推荐
- [SDOi2012]Longge的问题 BZOJ2705 数学
题目背景 SDOi2012 题目描述 Longge的数学成绩非常好,并且他非常乐于挑战高难度的数学问题.现在问题来了:给定一个整数N,你需要求出∑gcd(i, N)(1<=i <=N). ...
- select 插入数据 不自增列实现自增
- 洛谷 P2330 [SCOI2005]繁忙的都市(最小生成树)
嗯... 题目链接:https://www.luogu.org/problemnew/show/P2330 这道题的问法也实在是太模板了吧: 1.改造的道路越少越好 2.能够把所有的交叉路口直接或间接 ...
- 请求一个域名ip的缓存用处
前言 摘录自操作系统,这一段的内容很有启发,稍微加上自己的理解,写一篇博客记录一下. 缓存 缓存成功解决了速度不匹配设备之间的数据传输,并且在一般情况下,是整个系统的瓶颈:缓存的出现,有效减少了低速I ...
- LeetCode934.shortest bridge【dfs+bfs】
一.题面 在给定的二维二进制数组 A 中,存在两座岛.(岛是由四面相连的 1 形成的一个最大组.) 现在,我们可以将 0 变为 1,以使两座岛连接起来,变成一座岛. 返回必须翻转的 0 的最小数目.( ...
- bzoj3224 普通平衡树 splay模板
题目传送门 题目大意:完成一颗splay树. 思路:模板题,学着还是很有意思的. 学习splay树:蒟蒻yyb 该题模板:汪立超 #include<bits/stdc++.h> #defi ...
- HDU - 1520 树形DP入门题
写了两种DP,第一种是按照自己习惯来xjb敲的,第二种参考别人 熟悉一下树形DP的套路 dp[i][]是维护i及以下的关系最优值的,所以我觉得两次DP记忆搜索之间不清-1应该是正确的(也就做了一次加法 ...
- TransactionScope小例
1 public static class DataTableHelper { public static List<T> ToModel<T>(this DataTable ...
- 给新人看的 JavaScript的继承
//这个继承方式是给新人看的,逻辑简单一些 Object.extend=function(props){ //继承父类 var prototype=Object.create(this.prototy ...
- Gym - 100989
B Although Haneen was able to solve the LCS problem, Dr. Ibrahim is suspicious about whether she rea ...