目录
Map接口的继承结构
首先要知道Map和Collection没有关系，他们只是都在java.util包下
Map接口的实现类：HashMap、Hashtable、TreeMap
- HashMap底层实现是哈希表（又叫散列表），非线程安全的。
- Hashtable底层实现是哈希表，线程安全的，效率低，使用较少。
需要了解：Hashtable的子类Properties：也是线程安全的，他也是以key和value为键值对存储的，但是key和value只能是String类型的。Properties被称为属性类。 - TreeMap底层实现是红黑树（自平衡二叉树），是非线程安全的，他是的子接口SortedMap接口的实现类，TreeMap中存储的元素按大小排序，树结构中遵循左小右大原则。
HashMap与Hashtable的比较
-
hashMap线程不安全，hashtable线程安全
-
hashMap<k,v>键值对可以为空，hashtable<k,v>键值对不可以为空，键都是唯一的
-
hashMap的父类是AbstractMap，hashtable的父类是Dictionary
-
hashMap的初始容量是16，hashtable的初始容量是11
-
hashMap的每次扩容为原来容量的2倍(
oldCap<<1)，hashtable扩容为原来的2倍+1((oldCap<<1)+1) -
hashMap计算hash值
key.hashCode()^(h>>>16)，hashtable计算hash值key.hashCode()在并发的情况下我们一般使用ConcurrentHashMap而不是hashtable
Map的存储方式
Map以key value 键值对的形式存储元素（value中保存的是对象的内存地址）
Map集合中的key唯一且不重复，value可重复。
（key和value都可以为null，但是key唯一且不重复，所以在Map集合中只能有一个key值为null）
把Map集合中的所有key值拿出来，可以看成一个Set集合。
Set集合：
Hash Set是Set的实现类，他是无序且不重复的，底层也是哈希表。
（无序的意思是：它存入的顺序和取出的顺序不一样，不同于数组，存入的第一个元素位于下标为0的位置，他的下标（位置）是通过hash算出来的）
HashMap源码分析
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
/*hashMap默认的初始容量为16
源码中的一句注释：MUST be a power of two.每次扩容后容量一定是2的次幂
这可以使散列表分布均匀，这使得哈希表查找与增删的性能都比较均衡，散列分布不均匀
的情况则会导致哈希表的性能变差，比如数组过长或者链表过长
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/*0.75是负载因子，意思是当存储元素的容量达到了原容量的75%的时候，
hashMap将自动扩容，其实底层就是数组的扩容*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当链表长度>8时，链式结构转为红黑树结构
static final int TREEIFY_THRESHOLD = 8;
//当树节点<6时，树结构再次转为链表
static final int UNTREEIFY_THRESHOLD = 6;
/*hashMap的底层是一个Node的节点数组Node<K,V>[]
transient关键字：如果一个类实现了Serializable接口，是指这个类可以被序列化，
但是transient修饰的这个属性不参与序列化，反序列化时将被初始化为null*/
transient Node<K,V>[] table;
/*静态内部类：声明了在节点数组中每个节点都有4个属性，以及都重写了hashCode()和equals()方法
我删掉了一些getset方法和构造方法*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //它是key.hashCode()的返回结果
final K key; //Map中的key
V value; //Map中的value
Node<K,V> next; //下一个节点的内存地址
//重写hashCode方法
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
//重写equals方法 Map.Entry是Map的一个内部类，<k,v>是一个Entry实例
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;
}
}
}
//构造函数之一 给定初始容量和负载因子
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;
// 扩容值阈threshold: 这个方法对输入的初始化容量做了处理，保证数组的容量总是2的次方
this.threshold = tableSizeFor(initialCapacity);
}
HashMap的结构（JDK8）
数组+链表+红黑树的结构，这种结构分别综合了数组检索快和链表增删快（树的检索效率也比较高）的优点，使哈希表拥有一个比较平衡高效的性能。
从源码中可以看出：
当链表长度>8时，链式结构转为红黑树结构；
当树节点<6时，树结构再次转为链表；
node对象：hash值，key，value，next指向下一个node对象的指针，指向null表示没有下一个元素，当前元素就是该链表上的最后一个元素。
HashMap的存取
map.put(k,v);
往数组中添加元素时，首先要获取key和value，获取key的hash值（这里的hash(key)的返回结果又经过了一个扰动函数，会使得求出的下标更分散，散列表分布更均匀，性能更高），next指针指向null，构造出一个node对象；经过数学表达式的计算可以得出这个node对象在数组中放在哪个位置上（ 路由寻址公式：(table.length-1)&node.hash ），如果这个下标位置是空的，直接放入node对象；如果不为空，就比较链表中每个node对象的key和我们新创建的key进行equals比较，相等得话就替换value，没有相等的就加在链表末端。
map.get(k);
根据key值取出时，也是根据key的hash值算出下标，如果当前位置只有一个对象就直接返回value，如果是一个链表，那么就要比较链表中每个对象中的key的equals，相等就取出。
两个值的hashCode相等，他们的值不一定相等。（所以要同时重写hashCode和equals方法）
这又涉及到哈希碰撞问题
-
什么是哈希：
哈希算法的概念：我们把任意长度输入，通过哈希算法变成固定长度的输出，输出的值为哈希值。这种转换是一种压缩映射，将输入空间映射成哈希空间，而哈希空间远小于输入空间，根据抽屉原理（往9个抽屉中放10个苹果，那么一定有一个抽屉中有两个苹果），一定会存在不同的输入值被映射成相同的数据输出的情况。 -
哈希碰撞就是：不同的值会映射出相同的哈希值。
-
哈希碰撞会导致什么问题呢？
Node对象中有一个属性是key的hash值，有可能出现不同的key，却又相同的hash值，那么他们计算出来的下标是一样的，他们就都在一条链表上。这种情况如果多次发生，会导致哈希表结构发生链化，链表越来越长，哈希表结构分布不均，这样会降低哈希表的查询效率。
那么底层是如何优化哈希碰撞的呢？
1、扰动处理
让key.hashCode()的值的高位也参与运算，进一步降低hash碰撞的概率，使得数据分布更平均，我们把这样的操作称为扰动。
2、链表与红黑树的转化，链表长度>8时转为红黑树，链表查询效率低。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
HashMap的扩容
hashMap的扩容实际上就是底层Node数组的扩容。
主要是resize()方法，下面我们来看一下源码
/**
* resize()方法有两种使用：
* 1.初始化：数组为空则初始化容量
* 2.扩容：不为空就扩容
**/
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) {
if (oldCap >= MAXIMUM_CAPACITY) { //判断数组容量 大于数组允许的最大值就不扩了
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; //否则，就扩容为原来的2倍（左移1位）
}
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);
}
// 计算新的resize上限
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 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;
}
622
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
