HashMap与HashTable的区别？
ConcurrentHashMap和Hashtable的区别？
同步集合与并发集合？
内部常量
内部属性
内部类
构造方法
put方法流程
扩容原理
对于数组，如果已知下标i,那么查询一个元素就很快。但是如果不知道下标i,只知道元素的值，那么需要从头开始遍历数组，直到找到这个元素位置。
而有序表的查找，比如二分查找或插值查找，虽然提高了效率，但还是需要经过多次>、
那么有没有一种方法，可以直接通过关键字key来找到它在内存中的存储位置呢(即解决数组无法快速通过关键字key找到索引i的不足)？
散列技术首先我们引进一种新的技术，叫散列技术。散列技术是通过某个函数f，使得存储位置=f(关键字key)。
f称为散列函数(或哈希函数)；
通过散列函数而得到的一块连续存储空间称为散列表(或哈希表)；
关键字对应的存储位置称为散列地址；
散列技术既是一种存储方法，也是一种查找方法，存储和查找必须使用同一个散列函数。
散列表不适用的场景：不适合一对多的查找，如通过男性关键字查找班级所有的男生；
不适合范围查找；
直接定址法
数字分析法
平方取中法
折叠法
除留余数法(这种用的多)
随机数法
冲突：key1≠key2，但f(key1)=f(key2)
开放定址法：当冲突时，找到一个空白位置进行插入。又分为：线性探测(i+1,i+2,i+3,...)、二次探测(i+1^2,i+2^2,i+3^2,...。解决线性探测聚集现象)等；
再散列函数法：使用多种散列函数；
链地址法：又称为拉链法，HashMap就用的这种；
公共溢出区法：为所有冲突的关键字建立了个公共的溢出区来存放；
java.util.Map的实现类HashMap、Hashtable、LinkedHashMap、TreeMap、ConcurrentHashMap之间的关系？
HashMap与HashTable的区别？
HashMap线程不安全，Hashtable线程安全;
HashMap允许K/V都为null；后者K/V都不允许为null;
HashMap继承自AbstractMap类；而Hashtable继承自Dictionary类;
ConcurrentHashMap和Hashtable的区别？
ConcurrentHashMap结合了HashMap和HashTable二者的优势;
HashMap 没有考虑同步，HashTable 考虑了同步的问题;
但是HashTable 在每次同步执行时都要锁住整个结构，ConcurrentHashMap 锁的方式是稍微细粒度的;
同步集合与并发集合？
Collections.synchronizedMap()方法可以获取一个线程安全的map，称为同步集合，锁住整个方法(粗粒度);
ConcurrentHashMap 是并发集合，锁是细粒度的;
ConcurrentHashMap，它内部细分了若干个小的HashMap，称之为段(Segment)。默认情况下一个ConcurrentHashMap被进一步细分为16个段，既就是锁的并发度(分段锁);
不管是同步集合还是并发集合，都能保证线程安全，但建议使用并发集合;
LinkedHashMap按插入顺序存储，TreeMap可对键排序
HashMap存储结构大部分编程语言都有哈希表的实现，Java也不例外，HashMap就是典型代表。
Java7中HashMap的存储结构采用数组+单向链表，如图1所示；Java8中进一步优化，采用数组+单向链表+红黑树，如图2所示。
Entry数组也可以称它为哈希桶数组。
图1
图2
哈希桶数组越大越好吗？
如果哈希桶很大，即使较差的Hash算法也会比较分散；
如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰撞；
所以就需要在空间成本和时间成本之间权衡，根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。
为什么引入红黑树？
即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。
于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。当链表长度太长(默认超过8)时，链表就转换为红黑树，利用红黑树快速增删查的特点提高HashMap的性能。
源码剖析使用jdk1.8版本；
与红黑树相关的代码暂不剖析，如果讲红黑树就太复杂了，我后面单独写一篇文章作为专题来剖析；
// 默认的初始化容量，16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 默认的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 链表长度达到8时转化为红黑树
static final int TREEIFY_THRESHOLD = 8;
// 结点个数小于等于6时，红黑树退化为单链表
static final int UNTREEIFY_THRESHOLD = 6;
// 树的最小容量
static final int MIN_TREEIFY_CAPACITY = 64;哈希桶数组的默认大小为16，默认负载因子为0.75，而扩容的阈值threshold=哈希桶数组大小*负载因子。
为什么哈希桶数组的大小一定要是2的n次方？因为HashMap计算索引的方式是hash & (length-1)，如果length为2的n次方，那么length-1的二进制码低位全为1。比如当length=16，那么15的二进制码为00001111，低4位全为1，那么&运算的结果取决于hash;相反地，如果length不为2的n次方，那么低位必有0，作&运算会导致该位恒为0，如图3所示。由于&运算的结果会作为数组索引，而低3位的&运算结果却恒为0，这样会造成数组空间的浪费。
扩容时，方便定位。假设扩容前容量为16，如果每次都扩容2倍的话，扩容后容量为32，假如现在一个hash值为50，那么扩容前的索引为2，扩容后的索引为18=16+2=原索引+原容量，之所以有这样一个公式得益于新容量是原容量的2倍(其实3的n次方也可以，但是2的n次方更加简单，大家可以细想一下为什么)。
图3
为什么最大容量是2的30次方？首先，哈希桶的容量一定要是2的n次方。整数最大值是2^31-1，那么2的31次方就超出范围了，所以是2的30次方。
为什么长度超过8转化为红黑树，而长度小于6时才退化为链表呢？
选择8的原因是，红黑树平均时间复杂度为logn，链表为n/2，当长度为8时，链表查找时间为4=8/2，红黑树为3=log8，因此设为8比较合适；
选择8和6的原因是，让其中间有个差值7，当我们的HashMap频繁地插入、删除元素，那么链表和红黑树两者可能就会频繁地转化，设一个差值7可以有效减少这种频繁的转化；
内部属性
// 哈希表
transient Node[] table;// Entry集合transient Set> entrySet;// 实际存储kv对的个数transient int size;// HashMap内部结构发生变化的次数transient int modCount;// 初始化数组容量，若threshold为0，则初始化数组容量为16int threshold;// 负载因子final float loadFactor;内部类
HashMap中有很多内部类，这里重点关注两个。分别是普通结点和红黑树结点，我只列举了它们的属性。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node next;
}static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode parent;
TreeNode left;
TreeNode right;
TreeNode prev; boolean red;
}HashMap一共有四个构造方法，如下图所示。
图4
从这些构造方法可知，主要有以下参数：int initialCapacity：初始容量
float loadFactor：负载因子
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}无参构造方法采用默认负载因子0.75，而初始化数组容量采用默认容量16，数组是在put方法的时候初始化的，这个下面会讲到。
而带参构造方法如下所示。
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);
}
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;
}如果我们使用了有参构造方法(图4中的第一个和第二个)，即显式指定了初始化容量，tableSizeFor方法还会做一层处理。
假如我们设置初始化容量为18，即cap=18，那么tableSizeFor方法的返回值就是32，为什么呢？因为HashMap要求哈希桶数组大小必须为2的n次方，那么比18大的第一个2的n次方就是32。
放心，扩容的时候会将这个loadFactor给乘上的，下面你就会了解到。
想要剖析HashMap源码，那么put方法是最重要的切入点。从put方法切入，可以看到hash函数、扩容、解决冲突、链表转化为红黑树、红黑树退化为链表等重要功能的源码。
先来通过一张图，总览一下put的流程( 注意：图是根据源码来的，所以还是以看源码为主，源码看懂了，心中自有图)。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}int h = key.hashCode();
h ^ (h >>> 16);HashMap计算数组下标的方式，不是传统的%求余，而是采用hash & (length-1)。而在大多数情况下，哈希桶数组的大小都小于2^16，因此length-1的二进制码的前16位都是0，如果直接用hashCode的话，hashCode的高16位恒为0(注意是&运算)，如此一来hashCode的高16位就参与不到计算中来。
因此将hashCode右移16位，再异或hashCode(&运算的结果偏向0、|运算的结果偏向1，^运算结果比较均匀)，这样hashCode的低16位和高16位都能参与计算了。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node[] tab; // 哈希桶数组
Node p; // 结点int n; // 哈希桶数组长度int i; //索引// 如果哈希桶数组为null 或 长度为0if ((tab = table) == null || (n = tab.length) == 0)// 对哈希桶数组进行扩容
n = (tab = resize()).length;// 标记1：通过i = (n - 1) & hash计算，得到索引为i的槽位为空if ((p = tab[i = (n - 1) & hash]) == null)// 则直接new一个Node，将其放入空槽位
tab[i] = newNode(hash, key, value, null);else {
Node e;
K k;// 要put的key 与 标记1中获取的对象p地址相同(是==判断的)，那么equals一定相等，从而hashcode也一定相等// 要put的key 与 标记1中获取的对象p equals相等if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))// 满足上述两个条件之一，则表明要put的key 与 标记1中获取的对象p是同一个对象
e = p;// 表示该槽位是红黑树else if (p instanceof TreeNode)// 委托给putTreeVal方法，让它去处理红黑树结点的插入
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);else {// 表示该槽位是单链表,则在该单链表上顺序查找for (int binCount = 0; ; ++binCount) {// 代表在该单链表上没有找到相同的keyif ((e = p.next) == null) {// 则直接在单链表的末尾插入新结点
p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1)// 超过了阈值，委托给treeifyBin方法将单链表转换为红黑树
treeifyBin(tab, hash);break;
}//代表在该单链表上找到了相同的keyif (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))break;
p = e;
}
}// 如果成功插入了，则e为null，如果要插入的key已存在，则e为已存在的结点if (e != null) { // existing mapping for key
V oldValue = e.value;if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);return oldValue;
}
}//成功插入新结点后，需要记录modCount，且判断是否有必要进行扩容
++modCount;if (++size > threshold)// kv对个数超过阈值，则扩容
resize();
afterNodeInsertion(evict);return null;
}数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组；
扩容是一个特别耗性能的操作，因此在使用HashMap的时候，估算map的大小，初始化的时候给一个大致的数值，避免map进行频繁的扩容；
final Node[] resize() {
Node[] oldTab = table; // 旧的哈希桶数组int oldCap = (oldTab == null) ? 0 : oldTab.length; // 旧的容量int oldThr = threshold; // 旧的阈值int newCap = 0; // 新的容量int newThr = 0; // 新的阈值// 旧容量不为0时，出现这种情况，表示哈希表已经初始化if (oldCap > 0) {if (oldCap >= MAXIMUM_CAPACITY) {// 如果旧容量已经达到最大容量，则将阈值设为int的最大值，且不进行扩容
threshold = Integer.MAX_VALUE;return oldTab;
}// 旧容量>=默认容量 且 扩容后的新容量 < 最大容量,则容量和阈值都扩大两倍else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1;
}// 标志1：阈值大于0时，新容量=阈值。出现这种情况是因为调用了有参构造方法，且是第一次put元素(即哈希表还未初始化)else if (oldThr > 0)
newCap = oldThr;// 当旧容量和旧阈值都是0时，进入此分支。出现这种情况是因为调用了无惨构造方法else { // 新容量设为默认容量
newCap = DEFAULT_INITIAL_CAPACITY;// 新阈值就是默认容量*默认负载因子
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}// 出现这种情况，是因为走了上面标志1的代码if (newThr == 0) {float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
Node[] newTab = (Node[])new Node[newCap]; // new一个Node数组，长度为新容量大小
table = newTab; // 将引用指向新的哈希桶// 旧哈希表不为null时，需要对旧哈希表上的元素向新哈希表做迁移；否则，不需要迁移，直接返回上一步new好的新哈希表if (oldTab != null) {// 遍历旧哈希桶for (int j = 0; j < oldCap; ++j) {
Node e; // 旧哈希桶的元素// 只将不为null的槽位 搬到 新的哈希桶数组中来if ((e = oldTab[j]) != null) {
oldTab[j] = null;if (e.next == null)// 表示该槽位只有一个元素，则新位置为e.hash & (newCap - 1)// 新位置与旧位置的关系：如果hash/旧容量=偶数，那么新位置与旧位置相同，否则不同
newTab[e.hash & (newCap - 1)] = e;else if (e instanceof TreeNode)// 表示该槽位是红黑树结构
((TreeNode)e).split(this, newTab, j, oldCap);else { // 表示该槽位有多个元素，且是单链表结构// java7在复制单链表时，是在while循环里面，单个计算好数组索引位置后，单个地插入新数组中，在多线程情况下，会有回环问题// java8是等链表整个while循环结束后,才给新数组赋值，所以多线程情况下，也不会成环// 老值表示，迁移后索引不变的元素；新值表示索引会变// 举个例子，扩容前容量为16，扩容后容量为31，有两个元素，hash值分别为33,50，33在迁移前后的索引都为1，是老值；50在迁移前索引为2，迁移后索引为18=16+2，是新值
Node loHead = null; // 老值头指针
Node loTail = null; // 老值尾指针
Node hiHead = null; // 新值头指针
Node hiTail = null; // 新增尾指针
Node 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;
}什么是Java7的HashMap单链表复制时的成环问题？
在Java7中，单链表的复制会出现成环问题，造成此问题的原因是java7在复制单链表时，是在while循环里面，单个计算好数组索引位置后，单个地插入新数组中，在多线程情况下，会有成环问题；
Java8如何解决成环问题？
Java8是等链表整个while循环结束后,才给新数组赋值。且新、老值的头指针都是局部变量，所以多线程情况下，也不会成环；
关于更多Java7成环问题的形成原因请看这篇文章：https://www.cnblogs.com/wen-he/p/11496050.html；
图5
上面的所有内容就是关于我对HashMap的理解，HashMap是面试的一个高频问点，如果大家有什么疑问，可以在文章下面留言，觉得写的不错的点个赞或者在看哟！
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
