【集合框架】JDK1.8源码分析之IdentityHashMap(四)
一、前言
前面已经分析了HashMap与LinkedHashMap,现在我们来分析不太常用的IdentityHashMap,从它的名字上也可以看出来用于表示唯一的HashMap,仔细分析了其源码,发现其数据结构与HashMap使用的数据结构完全不同,因为在继承关系上面,他们两没有任何关系。下面,进入我们的分析阶段。
二、IdentityHashMap示例
import java.util.Map;
import java.util.HashMap;
import java.util.IdentityHashMap; public class IdentityHashMapTest {
public static void main(String[] args) {
Map<String, String> hashMaps = new HashMap<String, String>();
Map<String, String> identityMaps = new IdentityHashMap<String, String>();
hashMaps.put(new String("aa"), "aa");
hashMaps.put(new String("aa"), "bb"); identityMaps.put(new String("aa"), "aa");
identityMaps.put(new String("aa"), "bb"); System.out.println(hashMaps.size() + " : " + hashMaps);
System.out.println(identityMaps.size() + " : " + identityMaps);
}
}
运行结果:
1 : {aa=bb}
2 : {aa=bb, aa=aa}
说明:IdentityHashMap只有在key完全相等(同一个引用),才会覆盖,而HashMap则不会。
三、IdentityHashMap数据结构
说明:IdentityHashMap的数据很简单,底层实际就是一个Object数组,在逻辑上需要看成是一个环形的数组,解决冲突的办法是:根据计算得到散列位置,如果发现该位置上已经有元素,则往后查找,直到找到空位置,进行存放,如果没有,直接进行存放。当元素个数达到一定阈值时,Object数组会自动进行扩容处理。
四、IdentityHashMap源码分析
4.1 类的继承关系
public class IdentityHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, java.io.Serializable, Cloneable
说明:继承了AbstractMap抽象类,实现了Map接口,可序列化接口,可克隆接口。
4.2 类的属性
public class IdentityHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, java.io.Serializable, Cloneable
{
// 缺省容量大小
private static final int DEFAULT_CAPACITY = 32;
// 最小容量
private static final int MINIMUM_CAPACITY = 4;
// 最大容量
private static final int MAXIMUM_CAPACITY = 1 << 29;
// 用于存储实际元素的表
transient Object[] table;
// 大小
int size;
// 对Map进行结构性修改的次数
transient int modCount;
// null key所对应的值
static final Object NULL_KEY = new Object();
}
说明:可以看到类的底层就是使用了一个Object数组来存放元素。
4.3 类的构造函数
1. IdentityHashMap()型构造函数
public IdentityHashMap() {
init(DEFAULT_CAPACITY);
}
2. IdentityHashMap(int)型构造函数
public IdentityHashMap(int expectedMaxSize) {
if (expectedMaxSize < 0)
throw new IllegalArgumentException("expectedMaxSize is negative: "
+ expectedMaxSize);
init(capacity(expectedMaxSize));
}
3. IdentityHashMap(Map<? extends K, ? extends V>)型构造函数
public IdentityHashMap(Map<? extends K, ? extends V> m) {
// 调用其他构造函数
this((int) ((1 + m.size()) * 1.1));
putAll(m);
}
4.4 重要函数分析
1. capacity函数
// 此函数返回的值是最小大于expectedMaxSize的2次幂
private static int capacity(int expectedMaxSize) {
// assert expectedMaxSize >= 0;
return
(expectedMaxSize > MAXIMUM_CAPACITY / 3) ? MAXIMUM_CAPACITY :
(expectedMaxSize <= 2 * MINIMUM_CAPACITY / 3) ? MINIMUM_CAPACITY :
Integer.highestOneBit(expectedMaxSize + (expectedMaxSize << 1));
}
说明: 此函数返回的值是最小的且大于expectedMaxSize的2次幂的值。
2. hash函数
// hash函数,由于length总是为2的n次幂,所以 & (length - 1)相当于对length取模
private static int hash(Object x, int length) {
int h = System.identityHashCode(x);
// Multiply by -127, and left-shift to use least bit as part of hash
return ((h << 1) - (h << 8)) & (length - 1);
}
说明:hash函数用于散列,并且保证元素的散列值会在数组偶次索引。
3. get函数
public V get(Object key) {
// 保证null的key会转化为Object(NULL_KEY)
Object k = maskNull(key);
// 保存table
Object[] tab = table;
int len = tab.length;
// 得到key的散列位置
int i = hash(k, len);
// 遍历table,解决散列冲突的办法是若冲突,则往后寻找空闲区域
while (true) {
Object item = tab[i];
// 判断是否相等(地址是否相等)
if (item == k)
// 地址相等,即完全相等的两个对象
return (V) tab[i + 1];
// 对应散列位置的元素为空,则返回空
if (item == null)
return null;
// 取下一个Key索引
i = nextKeyIndex(i, len);
}
}
说明:该函数比较key值是否完全相同(对象类型则是否为同一个引用,基本类型则是否内容相等)
4. nextKeyIndex函数
// 下一个Key索引
private static int nextKeyIndex(int i, int len) {
// 往后移两个单位
return (i + 2 < len ? i + 2 : 0);
}
说明:此函数用于发生冲突时,取下一个位置进行判断。
5. put函数
public V put(K key, V value) {
// 保证null的key会转化为Object(NULL_KEY)
final Object k = maskNull(key); retryAfterResize: for (;;) {
final Object[] tab = table;
final int len = tab.length;
int i = hash(k, len); for (Object item; (item = tab[i]) != null;
i = nextKeyIndex(i, len)) {
if (item == k) { // 经过hash计算的项与key相等
@SuppressWarnings("unchecked")
// 取得值
V oldValue = (V) tab[i + 1];
// 将value存入
tab[i + 1] = value;
// 返回旧值
return oldValue;
}
} // 大小加1
final int s = size + 1;
// Use optimized form of 3 * s.
// Next capacity is len, 2 * current capacity.
// 如果3 * size大于length,则会进行扩容操作
if (s + (s << 1) > len && resize(len))
// 扩容后重新计算元素的值,寻找合适的位置进行存放
continue retryAfterResize;
// 结构性修改加1
modCount++;
// 存放key与value
tab[i] = k;
tab[i + 1] = value;
// 更新size
size = s;
return null;
}
}
说明:若传入的key在表中已经存在了(强调:是同一个引用),则会用新值代替旧值并返回旧值;如果元素个数达到阈值,则扩容,然后再寻找合适的位置存放key和value。
6. resize函数
private boolean resize(int newCapacity) {
// assert (newCapacity & -newCapacity) == newCapacity; // power of 2
int newLength = newCapacity * 2;
// 保存原来的table
Object[] oldTable = table;
int oldLength = oldTable.length;
// 旧表是否为最大容量的2倍
if (oldLength == 2 * MAXIMUM_CAPACITY) { // can't expand any further
// 之前元素个数为最大容量,抛出异常
if (size == MAXIMUM_CAPACITY - 1)
throw new IllegalStateException("Capacity exhausted.");
return false;
}
// 旧表长度大于新表长度,返回false
if (oldLength >= newLength)
return false;
// 生成新表
Object[] newTable = new Object[newLength];
// 将旧表中的所有元素重新hash到新表中
for (int j = 0; j < oldLength; j += 2) {
Object key = oldTable[j];
if (key != null) {
Object value = oldTable[j+1];
oldTable[j] = null;
oldTable[j+1] = null;
int i = hash(key, newLength);
while (newTable[i] != null)
i = nextKeyIndex(i, newLength);
newTable[i] = key;
newTable[i + 1] = value;
}
}
// 新表赋值给table
table = newTable;
return true;
}
说明:当表中元素达到阈值时,会进行扩容处理,扩容后会旧表中的元素重新hash到新表中。
7. remove函数
public V remove(Object key) {
// 保证null的key会转化为Object(NULL_KEY)
Object k = maskNull(key);
Object[] tab = table;
int len = tab.length;
// 计算hash值
int i = hash(k, len); while (true) {
Object item = tab[i];
// 找到key相等的项
if (item == k) {
modCount++;
size--;
@SuppressWarnings("unchecked")
V oldValue = (V) tab[i + 1];
tab[i + 1] = null;
tab[i] = null;
// 删除后需要进行后续处理,把之前由于冲突往后挪的元素移到前面来
closeDeletion(i);
return oldValue;
}
// 该项为空
if (item == null)
return null;
// 下一项
i = nextKeyIndex(i, len);
}
}
8. closeDeletion函数
private void closeDeletion(int d) {
// Adapted from Knuth Section 6.4 Algorithm R
Object[] tab = table;
int len = tab.length; // Look for items to swap into newly vacated slot
// starting at index immediately following deletion,
// and continuing until a null slot is seen, indicating
// the end of a run of possibly-colliding keys.
Object item;
// 把该元素后面符合移动规定的元素往前面移动
for (int i = nextKeyIndex(d, len); (item = tab[i]) != null;
i = nextKeyIndex(i, len) ) {
// The following test triggers if the item at slot i (which
// hashes to be at slot r) should take the spot vacated by d.
// If so, we swap it in, and then continue with d now at the
// newly vacated i. This process will terminate when we hit
// the null slot at the end of this run.
// The test is messy because we are using a circular table.
int r = hash(item, len);
if ((i < r && (r <= d || d <= i)) || (r <= d && d <= i)) {
tab[d] = item;
tab[d + 1] = tab[i + 1];
tab[i] = null;
tab[i + 1] = null;
d = i;
}
}
}
说明:在删除一个元素后会进行一次closeDeletion处理,重新分配元素的位置。
下图表示在closeDeletion前和closeDeletion后的示意图
说明:假设:其中,("aa" -> "aa")经过hash后在第0项,("bb" -> "bb")经过hash后也应该在0项,发生冲突,往后移到第2项,("cc" -> "cc")经过hash后在第2项,发生冲突,往后面移动到第4项,("gg" -> "gg")经过hash在第2项,发生冲突,往后移动到第6项,("dd" -> "dd")在第8项,("ee" -> "ee")在第12项。当删除("bb" -> "bb")后,进行处理后的元素布局如右图所示。
五、总结
IdentityHashMap与HashMap在数据结构上很不相同,并且处理hash冲突的方法也不相同。其中,IdentityHashMap只有当key为同一个引用时才认为是相同的,而HashMap还包括equals相等,即内容相同。
【集合框架】JDK1.8源码分析之IdentityHashMap(四)的更多相关文章
- 【集合框架】JDK1.8源码分析之HashMap(一) 转载
[集合框架]JDK1.8源码分析之HashMap(一) 一.前言 在分析jdk1.8后的HashMap源码时,发现网上好多分析都是基于之前的jdk,而Java8的HashMap对之前做了较大的优化 ...
- 【集合框架】JDK1.8源码分析之ArrayList详解(一)
[集合框架]JDK1.8源码分析之ArrayList详解(一) 一. 从ArrayList字表面推测 ArrayList类的命名是由Array和List单词组合而成,Array的中文意思是数组,Lis ...
- 【集合框架】JDK1.8源码分析之Collections && Arrays(十)
一.前言 整个集合框架的常用类我们已经分析完成了,但是还有两个工具类我们还没有进行分析.可以说,这两个工具类对于我们操作集合时相当有用,下面进行分析. 二.Collections源码分析 2.1 类的 ...
- 【集合框架】JDK1.8源码分析HashSet && LinkedHashSet(八)
一.前言 分析完了List的两个主要类之后,我们来分析Set接口下的类,HashSet和LinkedHashSet,其实,在分析完HashMap与LinkedHashMap之后,再来分析HashSet ...
- 集合之TreeSet(含JDK1.8源码分析)
一.前言 前面分析了Set接口下的hashSet和linkedHashSet,下面接着来看treeSet,treeSet的底层实现是基于treeMap的. 四个关注点在treeSet上的答案 二.tr ...
- 集合之LinkedHashSet(含JDK1.8源码分析)
一.前言 上篇已经分析了Set接口下HashSet,我们发现其操作都是基于hashMap的,接下来看LinkedHashSet,其底层实现都是基于linkedHashMap的. 二.linkedHas ...
- 集合之HashSet(含JDK1.8源码分析)
一.前言 我们已经分析了List接口下的ArrayList和LinkedList,以及Map接口下的HashMap.LinkedHashMap.TreeMap,接下来看的是Set接口下HashSet和 ...
- 【JUC】JDK1.8源码分析之ArrayBlockingQueue(三)
一.前言 在完成Map下的并发集合后,现在来分析ArrayBlockingQueue,ArrayBlockingQueue可以用作一个阻塞型队列,支持多任务并发操作,有了之前看源码的积累,再看Arra ...
- Java集合系列[4]----LinkedHashMap源码分析
这篇文章我们开始分析LinkedHashMap的源码,LinkedHashMap继承了HashMap,也就是说LinkedHashMap是在HashMap的基础上扩展而来的,因此在看LinkedHas ...
随机推荐
- 关于PHP中<?php ?>的结束标签是否添加
在纯PHP代码中“?>”结束标签最好不要添加 原因:容易导致输出多余的空白或者换行,以及由此产生的一些报错. 比如a.php文件中,在?>标签后面多出空格或者换行,而当b.php文件引入a ...
- js中的时间与毫秒数互相转换
1.js毫秒时间转换成日期时间 var oldTime = (new Date("2012/12/25 20:11:11")).getTime(); //得到毫秒数 //不 ...
- android ADT 无法查看第三方jar源代码
Source not foundThe JAR of this class file belongs to container 'Android Private Libraries' which do ...
- php入门一ubuntu16.04中php环境配置及一个网页
1.PHP(全称:PHP:Hypertext Preprocessor,即"PHP:超文本预处理器")是一种通用开源脚本语言. 2.PHP 文件可包含文本.HTML.JavaScr ...
- 跨平台移动开发UI语言 -XAML
Xamarin.Forms 把XAML (Extensible Application Markup Language, XAML) 带进了ios,android的界面开发,也就使得使用Xamarin ...
- 多种坐标系之间的转换 Proj.NET和DotSpatial
Proj.NET ( http://projnet.codeplex.com/)是一个.NET下开源的空间参照和投影引擎,遵循OGC相关标准.负责人(Coordinators )是D_Guidi 和S ...
- 使用VS2013分析DMP文件
当一个发布的.NET应用程序出现app crash,无法通过日志分析异常原因时,就需要通过分析DMP文件了,传统方式是通过WinDbg来分析DMP文件,但是WinDbg用起来不是很方便,其实VS就是一 ...
- [.net 面向对象程序设计进阶] (21) 反射(Reflection)(下)设计模式中利用反射解耦
[.net 面向对象程序设计进阶] (21) 反射(Reflection)(下)设计模式中利用反射解耦 本节导读:上篇文章简单介绍了.NET面向对象中一个重要的技术反射的基本应用,它可以让我们动态的调 ...
- Azure PowerShell (8) 使用PowerShell设置Azure负载均衡器规则
<Windows Azure Platform 系列文章目录> 注意:如果Azure面对的客户只是企业级客户,企业级客户使用NAT设备访问Internet的话,因为多个客户端使用相同的So ...
- JAVA spring hibernate 多数据源配置记录
数据源配置 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http:// ...