歇斯底里的剖析HashMap

HashMap在底层数据结构上采用了数组＋链表＋红黑树，通过散列映射来存储键值对数据因为在查询上使用散列码（通过键生成一个数字作为数组下标，这个数字就是hash code）所以在查询上的访问速度比较快，HashMap最多允许一对键值对的Key为Null，允许多对键值对的value为Null。它是非线程安全的。在排序上面是无序的。

进入正文之前先了解下关键字段

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默认初始容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子
static final int TREEIFY_THRESHOLD = 8;//树化的阈值
static final int UNTREEIFY_THRESHOLD = 6;//树转链表的阈值
static final int MIN_TREEIFY_CAPACITY = 64;//最小的树化的容量

开始进入正文，先构造一个hashMap，四个构造器

//无参数构造
public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR; // 默认加载因子0.75f}

//传初始容量
public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);}

//传初始容量和加载因子
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);//保证是最靠近的2次幂大小}

//传入map
public HashMap(Map<? extends K, ? extends V> m) {this.loadFactor = DEFAULT_LOAD_FACTOR;putMapEntries(m, false);}

接下来详解 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;if ((tab = table) == null || (n = tab.length) == 0)//第一次添加时成立n = (tab = resize()).length;if ((p = tab[i = (n - 1) & hash]) == null)//根据与运算来判断对象存放在数组上的具体位置，如果是此位置空，直接存放tab[i] = newNode(hash, key, value, null);else {//不为空，已经存在对象Node<K,V> e; K k;if (p.hash == hash &&   //确认key值相同((k = p.key) == key || (key != null && key.equals(k))))e = p;//存放在临时节点eelse if (p instanceof TreeNode)//key值不同，判断是否是红黑树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) // -1 for 1sttreeifyBin(tab, hash);//大于阈值，转化为红黑树break;}if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}if (e != null) { // e节点不为null，且key值相同，返回以前的对应的value值V oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;//替换旧的valueafterNodeAccess(e);return oldValue;}}++modCount;//修改次数加一if (++size > threshold)//size加一后，判断是否需要扩容resize();//扩容afterNodeInsertion(evict);return null;}

概要： put时，判断是否是第一次添加，是，扩容，添加，返回null。不是第一次，根据hash运算判断在数组上存放的具体位置，如果此位置为null，直接添加，不为null，判断key是否相同，相同，返回以前的值，不相同，判断是否为红黑树，是红黑树，添加入树，不是红黑树，添加在链表的尾端。判断是否大于阈值，大于阈值，转化为红黑树。最后++size，判断是否需要扩容。

扩容机制

show code ! ! !

final Node<K,V>[] resize() {Node<K,V>[] oldTab = table;//如果是第一次，为nullint oldCap = (oldTab == null) ? 0 : oldTab.length;int oldThr = threshold;int newCap, newThr = 0;if (oldCap > 0) {if (oldCap >= MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return oldTab;}else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)//容量大于或等于16扩容newThr = oldThr << 1; // 左移一位，两倍阈值,两倍扩容}else if (oldThr > 0) // newCap = oldThr;else {         //处理第一次扩容，也就是第一次putval时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;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 orderNode<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;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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;}

扩容的结果是两倍大小或者是初始化。

有一个问题就是怎么保证容量为2的幂，看看下面的源码，是怎么操作的，很巧妙

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

可以看到进行了一系列的无符号右移和或运算。感兴趣的小伙伴可以随便举一个数字试试，最后得到的一定是2的幂，而且低位的都是连续的1，高位都是0。至于为什么要减一，这是为了避免容量就是2的幂，不减一，高位都是1，加一，容量就变成了当前的两倍。

那为什么容量必须是2的幂呢？
这样可以减少hash冲突，使数据更加分散

hashMap是线程安全的吗
不是的，例如，当我们插入数据的时候，假设AB线程的key值相同，A线程判断桶的位置为NULL，此时A线程失去了执行权，B线程进来，咦，运气真好，直接添加，此时A回复执行权，发现不为null，且KEY一样，就会修改之前的值，而B线程一无所知。就会造成数据的丢失。

那么怎么才能安全的使用hashMap呢？
你可以在自己需要的时候加锁，当然，也可以使用集合工具类Collections.synchronizedMap或者说ConcurrentHashMap。

什么时候树化，我们看看下面就知道啦

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)resize();else if ((e = tab[index = (n - 1) & hash]) != null) {TreeNode<K,V> hd = null, tl = null;do {TreeNode<K,V> p = replacementTreeNode(e, null);if (tl == null)hd = p;else {p.prev = tl;tl.next = p;}tl = p;} while ((e = e.next) != null);if ((tab[index] = hd) != null)hd.treeify(tab);}}

为什么这样设计呢？
因为在数组容量较小的时候，如果转为红黑树，反而会降低效率，因为红黑树要进行左旋、右旋，变色等操作，而且容量小于64时，数组查询效率较高。

那么hash表是怎么计算数组索引值的呢？，还有什么方法可以计算数组索引值吗？
看源码

static final int hash(Object key) {int h;return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}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)n = (tab = resize()).length;if ((p = tab[i = (n - 1) & hash]) == null)tab[i] = newNode(hash, key, value, null);.............................

先计算key的hashCode，然后异或hashCode值无符号右移16位得到的值。最后在于数组长度-1进行与运算，得出数组的索引。得到数组索引值的方法很多，比如平方取中法，取余数，伪随机数法。但是都没有与运算效率高。

最后，在开发中要尽量避免数组的扩容，不管是rehash还是数据的复制，都及其消耗性能，这时可以指定初始容量或者说加载因子。

歇斯底里的剖析HashMap相关推荐

hashmap是单向链表吗_HashMap源码大剖析
本文目录哈希表的由来散列技术Map家族子类比较 HashMap与HashTable的区别? ConcurrentHashMap和Hashtable的区别? 同步集合与并发集合? HashMap存储结构 ...
【Java集合源码剖析】HashMap源码剖析
转载请注明出处:http://blog.csdn.net/ns_code/article/details/36034955 您好,我正在参加CSDN博文大赛,如果您喜欢我的文章,希望您能帮我投一票,谢 ...
hashmap put过程_阿里面试官：HashMap数据结构之道
问题1:HashMap的数据结构是什么样的? 同学1:嗯...数组+链表同学2:数组+链表... 同学3:数组+链表... 同学4:数组+链表+红黑树... 同学n:..... 为什么答案会有两种? ...
一文深度剖析ConcurrentHashMap
文章目录前言概述 jdk1.7 jdk1.8 源码分析常量值 initTable() putVal() helpTransfer() addCount() get() size() mappin ...
Android 开发工程师面试指南
原文链接:https://github.com/GeniusVJR/LearningNotes <Android 开发工程师面试指南 LearningNotes >,作者是知乎Androi ...
腾讯offer是什么样子_月薪35K：2020腾讯Java后端开发详细面试流程
背景 2017年我毕业于某不知名二本院校,校招进入一安防企业; 从事于后台服务接入工作.期间一直不断的提高自己,终于在今年如愿以偿,获得腾讯后台开发岗位offer.因此想借此分享成长路上的思考与困难, ...
面试增删改查用的java知识,工作3年的程序员，面试还说自己只会增删改查？这些高频面试题还不看起来！...
前言我们都知道 Java 的知识面非常广,面试问的涉及也非常广泛,重点包括:Java 基础.Java 并发,JVM.MySQL.数据结构.算法.Spring.微服务.MQ等等,涉及的知识点何其庞大, ...
【获奖榜单公布】遇见27岁的Java，分享你的开发者故事
征文活动官网:https://marketing.csdn.net/p/264aeefaf27a0e052b3f2ef8ab388dc4 1995 年 5 月 23 日,Java 诞生. 凭借着&qu ...
1.12Java-集合
目录 1.12.1集合 1.12.1.1什么是集合 1.12.1.2集合体系 1.12.2Collection接口 1.12.2.1 Collection概述 1.12.2.2 Collection方 ...

歇斯底里的剖析HashMap

扩容机制

歇斯底里的剖析HashMap相关推荐

最新文章

热门文章