哈希表结构(链表散列:数组+链表)实现,结合数组和链表的优点。当链表长度超过 8 时,链表转换为红黑树。
transient Node<K,V>\[\] table;
Hash算法:将任意数据转换为一个指定大小范围的数据,通常256字节以内,且相同的数据得到的hash值相同, 通常使用为MD5、 快速索引查找,HashMap等
HashMap 基于 hashing 原理,我们通过 put() 和 get() 方法储存和获取对象。
当我们将键 值对传递给 put() 方法时,它调用键对象的 hashCode() 方法来计算 hashcode,通过与数组的大小取余,然后找到 数组(bucket )位置来储存 Entry 对象。
当两个对象的 hashcode 相同时,它们的 bucket 位置相 同,‘碰撞’会发生。因为 HashMap 使用链表存储对象,这个 Entry 会存储在链表中
当获 取对象时,通过键对象的 equals() 方法找到正确的键值对,然后返回值对象
存储对象时,将 K/V 键值传给 put() 方法:
①、调用 hash(K) 方法计算 K 的 hash 值,然后结合数组长度,计算得数组下标;
②、调整数组大小(当容器中的元素个数大于 capacity * loadfactor 时,容器会进行扩容resize 为 2n)
③、i.如果 K 的 hash 值在 HashMap 中不存在,则执行插入,若存在,则发生碰撞;
ii.如果 K 的 hash 值在 HashMap 中存在,且它们两者 equals 返回 true,则更新键值对
iii. 如果 K 的 hash 值在 HashMap 中存在,且它们两者 equals 返回 false,则插入链表的尾部(尾插法)或者红黑树中(树的添加方式)。
(JDK 1.7 之前使用头插法、JDK 1.8 使用尾插法)(注意:当碰撞导致链表大于 TREEIFY_THRESHOLD = 8 时,就把链表转换成红黑树)
获取对象时,将 K 传给 get() 方法:
①、调用 hash(K) 方法(计算 K 的 hash 值)从而获取该键值所在链表的数组下标;
②、顺序遍历链表,equals()方法查找相同 Node 链表中 K 值对应的 V 值。
hashCode 是定位的,存储位置;equals是定性的,比较两者是否相等
发生hash碰撞,因为 hashCode 相同,则与数组的大小取余后,得到的索引是相同,所以会放生hash碰撞,不一定就是相等的(会继续通过equals方法比较)
所以两个对象所在数组的下标相同,"碰撞"就此发生。又因为 HashMap 使用链表存储对象,这个 Node 会存储到链表中。
这就是为什么一般我们会重写hash算法和equals方法原因
首先调用哈希函数获取Key对应的hash值,再计算其数组下标;
如果没有出现哈希冲突,则直接放入数组;如果出现哈希冲突,则以链表的方式放在链表后面;
如果链表长度超过阀值( TREEIFY THRESHOLD==8),就把链表转成红黑树,链表长度低于6,就把红黑树转回链表;
如果结点的key已经存在,则替换其value即可;
如果集合中的键值对大于12,调用resize方法进行数组扩容。”
创建一个新的数组,其容量为旧数组的两倍,并重新通过hash算法计算旧数组中结点的存储位置。结点在新数组中的位置只有两种,原下标位置或原下标+旧数组的大小。
①、table 数组大小是由 capacity 这个参数确定的,默认是16,也可以构造时传入,最大限制是1<<30;
②、loadFactor 是装载因子,主要目的是用来确认table 数组是否需要动态扩展,默认值是0.75,比如table 数组大小为 16,装载因子为 0.75 时,threshold 就是12,当 table 的实际大小超过 12 时,table就需要动态扩容;
③、扩容时,调用 resize() 方法,将 table 长度变为原来的两倍(注意是 table 长度,而不是 threshold)
④、如果数据很大的情况下,扩展时将会带来性能的损失,在性能要求很高的地方,这种损失很可能很致命。
一般情况下,使用最多的是 HashMap。
HashMap:在 Map 中插入、删除和定位元素时;
TreeMap:在需要按自然顺序或自定义顺序遍历键的情况下;
LinkedHashMap:在需要输出的顺序和输入的顺序相同的情况下。
HashMap 是非 synchronized 的,性能更好,HashMap 可以接受为 null 的 key-value,而 Hashtable 是线程安全的,比 HashMap 要慢,不接受 null 的 key-value。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
···
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
···
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
···
}
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable {
···
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
···
addEntry(hash, key, value, index);
return null;
}
···
public synchronized V get(Object key) {
HashtableEntry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (HashtableEntry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}
···
}
HashTable 使用一把锁(锁住整个链表结构)处理并发问题,多个线程竞争一把锁,容易阻塞;
ConcurrentHashMap
JDK 1.7 中使用分段锁(ReentrantLock + Segment + HashEntry),相当于把一个 HashMap 分成多个段,每段分配一把锁,这样支持多线程访问。锁粒度:基于 Segment,包含多个 HashEntry。
JDK 1.8 中使用 CAS + synchronized + Node + 红黑树。锁粒度:Node(首结
点)(实现 Map.Entry)。锁粒度降低了。
因为 String 是不可变的,也是 final 的,而且已经重写了 equals() 和 hashCode() 方法了。
其他的 wrapper 类也有这个特点。不可变性是必要的,因为为了要计算 hashCode(),就要 防止键值改变,如果键值在放入时和获取时返回不同的 hashcode 的话,那么就不能从 HashMap 中找到你想要的对象。
不可变性还有其他的优点如线程安全。如果你可以仅仅通过 将某个 field 声明成 final 就能保证 hashCode 是不变的,那么请这么做吧。因为获取对象 的时候要用到 equals() 和 hashCode() 方法,那么键对象正确的重写这两个方法是非常重要 的。
如果两个不相等的对象返回不同的 hashcode 的话,那么碰撞的几率就会小些,这样就 能提高 HashMap 的性能。
HashMap 参考其他问题;
LinkedHashMap 保存了记录的插入顺序,在用 Iterator 遍历时,先取到的记录肯定是先插入的;遍历比 HashMap 慢;
TreeMap 实现 SortMap 接口,能够把它保存的记录根据键排序(默认按键值升序排序,也可以指定排序的比较器)
之所以选择红黑树是为了解决二叉查找树的缺陷,二叉查找树在特殊情况下会变成一条线性结构(这就跟原来使用链表结构一样了,造成很深的问题),遍历查找会非常慢。
红黑树在插入新数据后可能需要通过左旋,右旋、变色这些操作来保持平衡,引入红黑树就是为了查找数据快,解决链表查询深度的问题,
我们知道红黑树属于平衡二叉树,但是为了保持“平衡”是需要付出代价的,但是该代价所损耗的资源要比遍历线性链表要少,所以当长度大于8的时候,会使用红黑树,如果链表长度很短的话,根本不需要引入红黑树,引入反而会慢。
通过时间复杂度分析:
红黑树的平均查找长度,也就是时间复杂度是log(n),长度为8,查找长度为log(8)=3,因为2的3次方是8
链表的平均查找长度为n/2,当长度为8时,平均查找长度为8/2=4,这才有转换成树的必要,因为log(8)比8/2小,用树结构需要的查找步数更少;链表长度如果是小于等于6,6/2=3,2
所以权衡考虑最终选择8是从时间复杂度考虑的结果,从8开始用树效率更好
每个节点非红即黑
根节点总是黑色的
如果节点是红色的,则它的子节点必须是黑色的(反之不一定)
每个叶子节点都是黑色的空节点(NIL节点)
从根节点到叶节点或空子节点的每条路径,必须包含相同数目的黑色节点(即相同的黑色高度)
在java 1.8中,如果链表的长度超过了8,那么链表将转换为红黑树。(桶的数量必须大于64,小于64的时候只会扩容)
发生hash碰撞时,java 1.7 会在链表的头部插入,而java 1.8会在链表的尾部插入
在java 1.8中,Entry被Node替代(换了一个马甲。
因为HashTable虽然线程安全,但是在多并发下效率低下,因为只要一个操作就会把整个Map都锁住,所以出现了ConCurrentHashMap这个ConcurrentHashMap在最外层不是一个大的数组,而是若干个Segment的数组,Segment继承了ReentrantLock,所以它就是一种可重入ReentrantLock
包含一个与HashMap数据接口差不多的链表数组,先是通过hash算法,然后选择不同的Segment数组,然后是根据数组链表进行存储,主要解决并发问题,
相信到这里,应付面试分分钟搞定了,但是为了提升自身能力,还是通过查看源码,并在实际项目中加之以运用才能熟能生巧。