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