1.2 Map体系
1.2.1 HashMap & Hashtable
1)底层实现和特点
HashMap和Hashtable底层都是由哈希表实现,HashMap和Hashtable的关系与ArrayList和Vector的关系是一样的。HashMap线程不安全,Hashtable线程安全。
特点:HashMap的key无序不可重复,value可以重复
2)哈希表的介绍
什么是哈希表?
哈希表是一种用于快速查询的数据结构,在精准定位方面性能非常的好(通过key找value),查找速度和元素的个数无关(理想状态,实际过程中,多少还是有点关系),时间复杂度为O(1)
优势:可以快速的通过key找到value。 快速定位、大数据去重、判断是否存在… 哈希表???
什么是哈希函数?
可以将任意类型的key转换成int类型下标
特点:
1、任何类型 -> int类型
2、同一个值 在 任何时候,转换的下标必须一样
3、转成的下标必须落在哈希表的有效范围之内自己实现一个哈希函数?
实现:key.hashcode() % array.length
什么是哈希碰撞?(哈希冲突 - 重要)
两个元素(key-value),通过哈希函数计算出同一个下标,如果key相同,则后面的元素value覆盖前面的元素value,如果key不同,则发生了所谓的哈希碰撞。哈希碰撞不是好事,而是因为不可避免。
**问题1:**哈希表是如何判断key是否相同的?
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) 先判断两个key的hash值是否相同,如果相同,再判断两个元素的key是否相等(== 或者 equals)
**问题2:**哈希碰撞发生后该怎么办?
哈希冲突的解决
1、开发地址法 - 发生碰撞后,新的元素自动往后移位
2、链地址法 - 将发生碰撞的元素通过链表连接起来(优势,不占其他的桶,劣势,影响查询性能)注意:JDK1.8之后,引入了链表 + 红黑树的方式解决哈希冲突
为什么要用链表 + 红黑树,而且是链表大于8的时候
最初链表还不是很长,所以可能 O(n) 和 O(log(n)) 的区别不大,但是如果链表越来越长,那么这种区别便会有所体现。所以为了提升查找性能,需要把链表转化为红黑树的形式。
哈希表的扩容
为什么哈希表要扩容?
随着添加元素越来越多,适当的扩容可以降低发生哈希碰撞概率。以及重新计算原来节点的桶位置,打散原来链表的长度,起到提高查询效率的作用。扩容阈值:当元素个数达到扩容阈值之后,就会触发一次哈希表的扩容。
填充因子:扩容的元素比例,扩容阈值 = 哈希表容量 * 填充因子
3)红-黑树 - (简单介绍)
什么是红-黑树?
红-黑树是一种特殊的二叉搜索树,也是一种便于快速查询的数据结构,但是查询性能会比哈希表略低。
什么是二叉搜索树?
二叉树 -> 二叉搜索树。在二叉搜索树中,任何一个节点的所有左子节点都小于该节点,所有的右子节点都大于该节点,这种二叉树,就称之为二叉搜索树。
缺点:害怕树的失衡
红-黑树就是一个永远平衡的二叉搜索树
红黑规则
只要遵循了红黑规则的二叉搜索树就一定是平衡的
1、根节点一定是黑色
2、红色节点不能有红色的子节点(红红冲突)
3、从根节点触发,到任意一个叶子节点,经过的黑节点数量必须相同
4、新增的节点默认为红节点
红黑树的平衡手段
变色 + 旋转
4)HashMap源码解析 - JDK1.8
常用属性
/**
* 哈希表的默认初始长度 - 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
/**
* 哈希表的最大长度 - 2^30
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认填充因子 - 0.75
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 链表长度到8时转成红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 红黑树的个数到6时转成链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 哈希表的元素达到64时,链表才会转红黑树
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
底层哈希表
*/
transient Node<K,V>[] table;
/**
当前的拓展阈值,当元素个数达到这个值时,就触发扩容
*/
int threshold;
/**
当前的填充因子
*/
final float loadFactor;
哈希表中的节点元素
//哈希表的节点
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //当前节点的hash值,通过key计算而来
final K key; //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;
}
}
构造方法
/**
* 无参构造
*/
public HashMap() {
//设置当前的填充因子为默认的填充因子 0.75f
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
/**
有参构造
参数1:初始化的哈希表的长度
参数2:填充因子
*/
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;
//1 2 4 8 16 32 64 128 ......
//根据初始容量,计算离这个容量最近的2的N次方的结果值
//设置给当前的扩容阈值
this.threshold = tableSizeFor(initialCapacity);
}
注意:JDK1.8之后,哈希表的容量必须是2的N次方
添加元素(put)
/**
添加元素
参数4:false代表,key相同时,value覆盖,如果为true,表示value不覆盖
*/
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);
}
/**
核心的添加元素的方法
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
//tab - 代表当前的哈希表
//p - 代表当前key对应的哈希桶中的元素
//n - 代表哈希表的长度
//i - 代表key对应的哈希桶的下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
//------------------第一次添加元素时触发-----------------------
//判断哈希表是否为空,如果为空表示当前第一次添加元素
if ((tab = table) == null || (n = tab.length) == 0)
//如果哈希表还没有初始化,就调用resize方法初始化哈希表
n = (tab = resize()).length;
//------------------第一次添加元素时触发-----------------------
//任何一个数字 & n 结果一定是0 ~ n范围
//(n - 1) & hash 通过key的哈希值计算下标,赋值给i
//从哈希表tab,下标为i的元素赋值给p
//判断p是否为null
if ((p = tab[i = (n - 1) & hash]) == null)
//说明当前哈希桶为空,没有发生哈希碰撞
//新建一个Node,将key,value等都保存到节点中
//将新的节点放入桶i的位置
tab[i] = newNode(hash, key, value, null);
else {
//桶i的位置不为空
//e - 哈希碰撞的桶的第一个元素
//k - 下标为i的哈希桶的第一个元素的key值
Node<K,V> e; K k;
//判断新增的key和p是否相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果相等 将p赋值给e
e = p;
else if (p instanceof TreeNode)
//判断当前哈希桶中是否为红黑树
//走红黑树的逻辑
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//哈希桶中是链表,并且发生了哈希碰撞
//遍历当前的桶的链表
for (int binCount = 0; ; ++binCount) {
//e一直指向p的下一个节点
if ((e = p.next) == null) {
//表示走到了最后一个节点,说明整个链表都没有发现相等的key
//创建一个新的节点,放入链表的尾端
p.next = newNode(hash, key, value, null);
//binCount - 循环的链表数量
//判断链表的长度是否达到转树的条件(有没有超过8)
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//可能转红黑树???
treeifyBin(tab, hash);
break;
}
//判断节点e是否和添加的元素key相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//当发现新增元素的key和某个元素的key相同时,e就不为null
//并且e代表当前这个相同的元素
if (e != null) { // existing mapping for key
//获得旧的value
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//value的覆盖
e.value = value;
afterNodeAccess(e);
//返回旧的value
return oldValue;
}
}
++modCount;
//判断当前元素数量,有没有超过扩容阈值
if (++size > threshold)
//进行扩容
resize();
afterNodeInsertion(evict);
return null;
}
/**
链表转红黑树的方法
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//判断当前哈希表的容量有没有达到64
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//如果没有达到64就进行一次扩容
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);
}
}
resize()方法有两个作用:
1、初始化哈希表
2、哈希表扩容思考:为什么要调用newNode方法创建节点,而不是直接new Node()?
扩容的方法(resize)
/**
1、哈希表的初始化
2、哈希表的扩容
*/
final Node<K,V>[] resize() {
//oldTab - 代表旧的哈希表
Node<K,V>[] oldTab = table;
//oldCap - 代表旧的哈希表容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldThr - 代表旧的扩容阈值
int oldThr = threshold;
//新的容量、新的扩容阈值
int newCap, newThr = 0;
if (oldCap > 0) {
//哈希表扩容走这里
//旧的哈希表有值的,不是第一次调用
if (oldCap >= MAXIMUM_CAPACITY) {
//表示旧的哈希表容量已经是最大值,无法再扩容
threshold = Integer.MAX_VALUE;
return oldTab;
}
//设置新的哈希表容量 = 旧容量 * 2
//设置新的扩展阈值 = 旧阈值 * 2
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else {
//第一次添加元素,哈希表还未初始化
//设置默认容量16为新的哈希表容量
newCap = DEFAULT_INITIAL_CAPACITY;
//设置新的扩展阈值为12
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;
//创建一个新的哈希表
//如果是第一个添加元素,则是创建一个长度为16的哈希表
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将新的哈希表赋值给全局变量
table = newTab;
//判断旧的哈希表是否为空
//如果是第一次添加元素,旧的哈希表必然为null,哈希表的初始化就到此为止
//如果不是第一次添加元素,那么还需要将旧的哈希表的元素重新计算下标移动到新的哈希表中
if (oldTab != null) {
//哈希表扩容走这里
//循环旧的哈希表
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//依次判断旧的哈希表中每个桶的元素是否null
if ((e = oldTab[j]) != null) {
//e代表旧的哈希表中桶j位置的元素
oldTab[j] = null;
//说明e只有一个元素,不是链表或者红黑树
if (e.next == null)
//将元素e重新计算下标,赋值到新的哈希表的指定位置
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//说明当前位置是一个红黑树,走红黑树的逻辑
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
//说明当前位置是一个链表
//低位链表
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;
}
TreeMap
1)底层实现和特点
特点:元素不可重复,有序(字典序)
底层实现:红-黑树。TreeMap的添加、查询的性能都会低于HashMap,除非真的需要Key有大小顺序,否则都应该使用HashMap。
问题:TreeMap如何判断两个key是否相同? 比较器的返回值是否为0
作业:自行查询get(key)方法的源码