jdk1.8HashMap源码实现分析
来源:互联网 发布:缓存和数据库一致性 编辑:程序博客网 时间:2024/05/17 07:21
**HashMap介绍
HashMap实现了Map接口,以key-value的形式存储。所以当需要以键值对存储的时候会选用HashMap
-HashMap源码分析
1)成员变量:
// 序列号 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;
2)构造函数:
HashMap共有四个构造函数
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; this.threshold = tableSizeFor(initialCapacity); }public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR);}public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted}public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
默认构造函数:HashMap()指定了初始容量为16,加载因子为0.75。DEFAULT_LOAD_FACTOR的值为0.75
HashMap(int initialCapacity)构造函数:加载因子仍为0.75,但是初始化容量可以自己定义,它调用了另外一个构造函数HashMap(int initialCapacity, float loadFactor)
HashMap(int initialCapacity, float loadFactor)构造函数:既可以自定因加载因子,又可以定义初始容量。前面几个构造函数都是通过调用这个函数进行初始化的
HashMap(Map< ? extends K, ? extends V> m):用集合去初始化
注:在构造函数中只是对loadFactor,threshold进行了初始化,没有对table数组进行初始化
那什么是加载因子和初始化容量呢,先来介绍一下HashMap的数据结构。jdk1.8中HashMap是一个数组加链表加红黑书的数据结构。当数组中,一条链的长度大于8时会转化为红黑树进行存储,当树结构中节点个数小于6时会转化为链表存储
table数组的大小就是初始容量。加载因子是其容量在自动增加之前可以达到的一种状态,形容的是达到多满的一种状态。0.75很适合,一般也不会再去对它进行修改了。在HashMap中,key-value会当作一个整体进行处理(即将它作为一个Entry节点),通过计算key的hash值将它存储进去,在jdk1.8的版本中为Node节点
3)Node节点
Node为HashMap的内部类,构成了table数组为链表
static class Node<K,V> implements Map.Entry<K,V> { final int 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; } 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; } }
实现了Map.Entry< K,V >接口。里面的成员变量有hash,到时候需要通过它去确定存储的位置。key键,value值。Node< K, V >next下一个节点。这里有三个比较重要的方法
setValue()方法:会返回旧值
hashCode值的计算:最终hashCode的值是通过计算key的hashCode和value的hashCode的值做异或运算
重写了equals方法
4)put方法:
put方法将键值进行存储:
public V put(K key, V value) { 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;//如果存储节点的table为null或者没有为里面的数组分配内存空间//则需要对table数组进行一次扩容 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;//最后节点在桶上的位置确定是由key的hash和数组长度减1进行与运算//共同确定下来的,如果那个位置没有存放节点,则直接将key,value//hash构成一个节点存储进去,next节点为null//注:最先加入进去的节点总是存储在table[i]这个位置上的 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);//如果计算所得的桶位置上已经有节点存放了 else { Node<K,V> e; K k;//p==table[i = (n - 1) & hash]//比较两个结点的键是否相同,比较方式:如果两个节点的hash值相//同,并且key也是相同的,这两个节点是相同的情况下则先将值//保存下来//因为hashMap中允许存在null值,所以key有两种比较的方法 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//如果不相等的情况下,则将节点添加到原来节点的后面//如果原来桶位置只有一个节点的话,则p.next = newNode(...)//否则需要移动到节点的next为null的那个节点上 else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e);//需要返回value的旧值 return oldValue; } } ++modCount; //进行了一次修改,需要修改modCount的值//++size以后在判断是否达到阈值,还不够恰当,如果此时扩容以后 //没有新元素加入,则进行了一次无效扩容 if (++size > threshold) resize(); afterNodeInsertion(evict); return null;}
put方法最终调用的是putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict)方法,在put方法中传入的hash值是通过调用hash方法计算得来的,我们先看一下它是如何计算的:
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
主要是通过key的值来计算,如果key为null,则返回null,所以HashMap中可以存储null值。如果不为null,则计算key的HashCode并和h >>> 16做异或,最后将hash值返回
putVal方法中成员变量简单介绍一下:
Node< K,V >[] table:table数组
Node< K,V >p:存储的key-value节点
n:table数组的长度
i:节点存储的位置
方法介绍:
1.首先判断table是不是空数组,如果是空数组的话,则调用resize方法将数组容量进行扩大
2.到这里我们才真正知道如何来存储的,计算i = (n - 1) & hash,获得节点存储位置,如果该位置没有其他的节点,则直接存储,并且下一个节点元素为null。之前计算key的hash这里终于用上了。那么为什么要这样计算呢。h&(length - 1)就相当于对length取模,而且速度比直接取模快得多,这样计算可以使table均匀分布数据,充分利用空间
3.如果原来的table表上已经有节点怎么办,先去查询该链上的key有没有相同的,如果有则直接用新值覆盖原来的旧值,并返回旧值,否则将该元素保存在链头(最先保存的元素放在链尾),并且将修改次数(modCount)加1
4)resize()方法:
作用:resize()既可以用来当桶中元素达到阈值时,进行扩容,也可以初始化数组,之前构造函数的时候都没有进行初始化table,初始化table是在第一次调用put方式时调用resize()方法实现的
final Node<K,V>[] resize() { //oldTab保存原来的table Node<K,V>[] oldTab = table; //原来数组的长度 int oldCap = (oldTab == null) ? 0 : oldTab.length; //原来数组的阈值 int oldThr = threshold; //新数组的阈值 int newCap, newThr = 0; if (oldCap > 0) { //这种情况下应该是数组已经被初始化了不为null if (oldCap >= MAXIMUM_CAPACITY) { //已经达到最大的初始容量了,则不扩容了,返回原来的数组 threshold = Integer.MAX_VALUE; return oldTab; } //old<<2,数组扩大为原来的两倍,阈值也扩大为原来的两倍 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } //以下是针对第一次数组初始化 //如果原来的数组的阈值大于0,则它成为新数组的阈值 else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; //返回的是大于initCapacity最小2的次方 //如果小于等于0的情况下则使用初始化默认值 //和jdk1.8版本之前的初始化类似 else { // zero initial threshold signifies using default newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } //调用resize()方法必定会调用if //这里确定newThre的值 if (newThr == 0) { float ft = (float)newCap * loadFactor; //如果newCapacity和ft都小于默认的最大值,则将使用ft,否则//即为允许的最大值 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; //将table赋值给类成员变量table //数组已经初始化过了,下面为当达到阈值桶需要扩容的操作 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; //依次将桶中的元素置为null,首先将桶中的值保存在e节点中 if ((e = oldTab[j]) != null) { oldTab[j] = null; 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 { // preserve order //如果不是树节点并且有多个节点的情况下 Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; 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; //返回新数组 }
代码稍微有点长,基本逻辑是这样的。第一次调用resize()方法时, 直接进入oldThr>0和newThre=0这两层逻辑。oldThr>0确定newCap的值,等于oldThr的值(oldThr为大于initCapacity的最小2的n次方)。newThre=0确定newThre的值,等于newCap*loadFactor。在总结一下,我们调用构造函数的时候,只会初始化loadFactor和initCapacity以及基于initCapacity初始化的threshold。在初始化table数组时,数组大小一般为threshold,threshold为initCapacity*loadFactor。特殊情况,当原来的threshold<=0的情况下,会调用默认的初始化值,即16和16*0.75。如果已经调用过一次resize()方法了,则在调用时则为扩容操作了,如果此时容量已经等于最大的初始化容量,则将不会进行扩容了,返回原先的数组。如果未达到最大容量,则将容量和阈值都扩大为原来的两倍。在扩容的过程中,会重新进行一次hash分配,在扩容以后的数组中找元素存在的位置,查找算法还是一样。这个过程非常耗时,所以使用前进行一下容量的估计,尽量避免扩容操作。因为目前对红黑数不是特别了解,所以没有讲解,以后再来补充
5)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;}
get方法最终调用的是getNode方法,所以重点研究一下getNode方法。
首先定位到table上(通过计算hash(key)&(n-1)),如果不为空的话,并且table[i]的key的hash值等于查找的key,则返回那个节点
如果不想等的话,则查找下一个节点,如果找不到的话将返回null
- jdk1.8HashMap源码实现分析
- JDK1.8 HashMap源码分析
- JDK1.8 HashMap源码分析
- 【jdk1.8】HashMap源码分析
- jdk1.8 hashMap源码分析
- JDK1.8 HashMap 源码分析
- JDK1.8 HashMap源码分析
- HashMap源码分析 JDK1.8
- jdk1.8 HashMap源码分析
- Java中HashMap底层实现原理(JDK1.8)源码分析
- Java中HashMap底层实现原理(JDK1.8)源码分析
- Java中HashMap底层实现原理(JDK1.8)源码分析
- HashMap源码分析(jdk1.8)
- HashMap源码分析——JDK1.8
- JDK1.8的HashMap源码分析
- Java源码分析之HashMap(JDK1.8)
- HashMap源码分析——JDK1.8
- JDK1.8源码分析之HashMap
- 洛谷P1561 [USACO12JAN]爬山Mountain Climbing(贪心)
- Struts2 配置默认action
- js倒计时
- idea实现热部署的几种方式
- js输入款字母数字正则
- jdk1.8HashMap源码实现分析
- 使用Cobbler批量安装操作系统
- eclipse编译错误
- C语言作业
- struts2 和ajax整合使用案例(原生态的ajax操作 和 struts2和ajax整合操作)
- layui 复选框等内置控件不显示问题
- Linux usb子系统(一) _写一个usb鼠标驱动
- LeetCode----- 86.Partition List
- Servlet详解(二)