集合操做-HashMap源码分析
HashMap有4个构造函数java
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);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
在HashMap中有两个很重要的参数，容量(Capacity)和负载因子(Load factor).node
Capacity就是bucket的大小，Load factor就是bucket填满程度的最大比例。若是对迭代性能要求很高的话不要把Capacity设置过大，也不要把Load factor设置太小。当bucket中的entries的数目大于Capacity*Load factor时就须要调整bucket的大小为当前的2倍。数组
static final float DEFAULT_LOAD_FACTOR = 0.75f;
先看下put方法：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
put函数大体的思路为：app
- 对key的hashCode()作hash，而后再计算index;
- 若是没碰撞直接放到bucket里；
- 若是碰撞了，以链表的形式存在buckets后；
- 若是碰撞致使链表过长(大于等于TREEIFY_THRESHOLD)，就把链表转换成红黑树；
- 若是节点已经存在就替换old value(保证key的惟一性)
- 若是bucket满了(超过load factor*current capacity)，就要resize。
get实现：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
get大体思路以下：函数
- bucket里的第一个节点，直接命中；
- 若是有冲突，则经过key.equals(k)去查找对应的entry
若为树，则在树中经过key.equals(k)查找，O(logn)；
若为链表，则在链表中经过key.equals(k)查找，O(n)。
resize实现：
当put时，若是发现目前的bucket占用程度已经超过了Load Factor所但愿的比例，那么就会发生resize。在resize的过程，简单的说就是把bucket扩充为2倍，以后从新计算index，把节点再放到新的bucket中性能
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;
}
// 没超过最大值，就扩充为原来的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 { // 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) {
// 把每一个bucket都移动到新的buckets中
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;
}
// 原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原索引放到bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
总结：
HashMap基于Map接口实现、容许null键/值、非同步、不保证有序(好比插入的顺序)、也不保证序不随时间变化this
能够总结几个常见问题：spa
HashMap的工做原理是什么？code
经过hash的方法，经过put和get存储和获取对象。存储对象时，咱们将K/V传给put方法时，它调用hashCode计算hash从而获得bucket位置，进一步存储，HashMap会根据当前bucket的占用状况自动调整容量(超过Load Facotr则resize为原来的2倍)。获取对象时，咱们将K传给get，它调用hashCode计算hash从而获得bucket位置，并进一步调用equals()方法肯定键值对。若是发生碰撞的时候，Hashmap经过链表将产生碰撞冲突的元素组织起来，在Java 8中，若是一个bucket中碰撞冲突的元素超过某个限制(默认是8)，则使用红黑树来替换链表，从而提升速度。对象
咱们可使用自定义的对象做为键吗？
固然你可能使用任何对象做为键，只要它遵照了equals()和hashCode()方法的定义规则，而且当对象插入到Map中以后将不会再改变了。若是这个自定义对象时不可变的，那么它已经知足了做为键的条件，由于当它建立以后就已经不能改变了。
equals()和hashCode()的都有什么做用？
经过对key的hashCode()进行hashing，并计算下标( n-1 & hash)，从而得到buckets的位置。若是产生碰撞，则利用key.equals()方法去链表或树中去查找对应的节点
若是HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？
若是超过了负载因子(默认0.75)，则会从新resize一个原来长度两倍的HashMap，而且从新调用hash方法。
为何桶的大小为2的幂次？
以Entry[]数组实现的哈希桶数组，用Key的哈希值取模桶数组的大小可获得数组下标。
插入元素时，若是两条Key落在同一个桶(好比哈希值1和17取模16后都属于第一个哈希桶)，Entry用一个next属性实现多个Entry以单向链表存放，后入桶的Entry将next指向桶当前的Entry。
查找哈希值为17的key时，先定位到第一个哈希桶，而后以链表遍历桶里全部元素，逐个比较其key值。
当Entry数量达到桶数量的75%时(不少文章说使用的桶数量达到了75%，但看代码不是)，会成倍扩容桶数组，并从新分配全部原来的Entry，因此这里也最好有个预估值。
取模用位运算(hash & (arrayLength-1))会比较快，因此数组的大小永远是2的N次方， 你随便给一个初始值好比17会转为32。默认第一次放入元素时的初始值是16。
hashMap遍历时为何是乱序？
iterator()时顺着哈希桶数组来遍历，看起来是个乱序。
HashSet
咱们顺便看一下HashSet的实现，它是由HashMap实现的，没有重复元素的集合。不保证元素的顺序，并且HashSet容许使用 null 元素。
package java.util;
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;
// HashSet是经过map(HashMap对象)保存内容的
private transient HashMap<E,Object> map;
// PRESENT是向map中插入key-value对应的value
// 由于HashSet中只须要用到key，而HashMap是key-value键值对；
// 因此，向map中添加键值对时，键值对的值固定是PRESENT
private static final Object PRESENT = new Object();
// 默认构造函数
public HashSet() {
// 调用HashMap的默认构造函数，建立map
map = new HashMap<E,Object>();
}
// 带集合的构造函数
public HashSet(Collection<? extends E> c) {
// 建立map。
// 为何要调用Math.max((int) (c.size()/.75f) + 1, 16)，从 (c.size()/.75f) + 1 和 16 中选择一个比较大的树呢？
// 首先，说明(c.size()/.75f) + 1
// 由于从HashMap的效率(时间成本和空间成本)考虑，HashMap的加载因子是0.75。
// 当HashMap的“阈值”(阈值=HashMap总的大小*加载因子) < “HashMap实际大小”时，
// 就须要将HashMap的容量翻倍。
// 因此，(c.size()/.75f) + 1 计算出来的正好是总的空间大小。
// 接下来，说明为何是 16 。
// HashMap的总的大小，必须是2的指数倍。若建立HashMap时，指定的大小不是2的指数倍；
// HashMap的构造函数中也会从新计算，找出比“指定大小”大的最小的2的指数倍的数。
// 因此，这里指定为16是从性能考虑。避免重复计算。
map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
// 将集合(c)中的所有元素添加到HashSet中
addAll(c);
}
// 指定HashSet初始容量和加载因子的构造函数
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<E,Object>(initialCapacity, loadFactor);
}
// 指定HashSet初始容量的构造函数
public HashSet(int initialCapacity) {
map = new HashMap<E,Object>(initialCapacity);
}
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);
}
// 返回HashSet的迭代器
public Iterator<E> iterator() {
// 实际上返回的是HashMap的“key集合的迭代器”
return map.keySet().iterator();
}
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean contains(Object o) {
return map.containsKey(o);
}
// 将元素(e)添加到HashSet中
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
// 删除HashSet中的元素(o)
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
public void clear() {
map.clear();
}
// 克隆一个HashSet，并返回Object对象
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
// java.io.Serializable的写入函数
// 将HashSet的“总的容量，加载因子，实际容量，全部的元素”都写入到输出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out HashMap capacity and load factor
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
// Write out size
s.writeInt(map.size());
// Write out all elements in the proper order.
for (Iterator i=map.keySet().iterator(); i.hasNext(); )
s.writeObject(i.next());
}
// java.io.Serializable的读取函数
// 将HashSet的“总的容量，加载因子，实际容量，全部的元素”依次读出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in HashMap capacity and load factor and create backing HashMap
int capacity = s.readInt();
float loadFactor = s.readFloat();
map = (((HashSet)this) instanceof LinkedHashSet ?
new LinkedHashMap<E,Object>(capacity, loadFactor) :
new HashMap<E,Object>(capacity, loadFactor));
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
}
HashSet的实现依赖于HashMap,若是理解了HashMap的实现，HashSet仍是比较容易理解的。
相关文章
- 1. 集合源码分析（六）HashMap集合
- 2. Java集合之HashMap源码分析
- 3. JAVA常用集合源码分析：HashMap
- 4. 集合源码分析（四）HashMap实现
- 5. java集合HashMap源码分析(JDK1.7)
- 6. 【JAVA集合】HashMap源码分析（转载）
- 7. Java集合源码分析（四）HashMap
- 8. 集合源码分析之三：HashMap源码解析（JDK8）
- 9. Java源码解析——集合框架（五）——HashMap源码分析
- 10. Java集合(6)之 HashMap 源码解析
- 更多相关文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • Java Agent入门实战（二）-Instrumentation源码概述
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. eclipse设置粘贴字符串自动转义
- 2. android客户端学习-启动模拟器异常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout问题
- 4. MYSQL8.0数据库恢复 MYSQL8.0ibd数据恢复 MYSQL8.0恢复数据库
- 5. 你本是一个肉体，是什么驱使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一个肉体，是什么驱使你前行【3】
- 9. 你本是一个肉体，是什么驱使你前行【2】
- 10. 【资讯】LocalBitcoins达到每周交易比特币的7年低点
欢迎关注本站公众号,获取更多信息
