HashMap特点
1.底层采用数组+链表+红黑树的数据结构；
2.key和value都允许为null；key不能重复
3.排列无序
4.线程不安全：java.util.Collections#synchronizedMap使HashMap具备线程安全的能力，或者使用ConcurrentHashMap；
HashMap成员变量
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
/**
* 默认初始化散列表数组的大小为16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
*Hash桶容量最大为2^30
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的负载因子，计算扩容阈值
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 当一个桶中的链表长度达到8时将链表转化为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
*
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
*
*/
static final int MIN_TREEIFY_CAPACITY = 6
/**
* 存储数据的hash桶
*/
transient Node<K,V>[] table;
/**
*
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* hash桶中元素个数
*/
transient int size;
/**
* hash桶更新次数
*/
transient int modCount;
/**
* 扩容阈值：hash桶容量乘负载因子：默认的大小为 (默认初始化大小)16*0.75（默认负载因子）=12 */
int threshold;
/**
* 负载因子，通过构造器传入
*/
final float loadFactor;
静态内部类(Hash桶存储的节点的数据结构)
static class Node<K,V> implements Map.Entry<K,V> {
//hash值，通过hash算法计算key的hash值
final int hash;
//key值
final K key;
//value值
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;
}
//获取key值
public final K getKey() { return key; }
//获取value值
public final V getValue() { return value; }
//重写tostring方法
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;
}
}
HashMap构造函数
- 通过构造函数实例化HashMap时，Hash桶的为null，只有添加元素时，才开始扩容。
/**
* initialCapacity:初始化Hash桶大小 ；loadFactor：负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
//初始化Hash桶大小小于0则抛异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//初始化Hash桶大小大于2^30,则初始化大小改为2^30
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//负载因子必须大于0并且必须是一个number isNaN:not a number
// Float f1 = new Float(-1.0/0.0);
//Float f2 = new Float(0.0/0.0);
//System.out.println(f1 + " = " + Float.isNaN(f1)); -Infinity = false
//System.out.println(f2 + " = " + Float.isNaN(f2)); NaN = true
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//赋值给成员变量
this.loadFactor = loadFactor;
//tableSizeFor方法，就是将该值进行扩大，保证能够一定是2的幂：将哈希表的大小固定为了2的幂，因 //为是取模得到索引值，故这样取模时，不需要做除法，只需要做位运算。位运算比除法的效率要高很多。
this.threshold = tableSizeFor(initialCapacity);
}
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
/**
* initialCapacity：初始化Hash桶大小 ；负载因子默认为0.75
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 这里给负载因子赋了一个默认值0.75f，扩容计算的时候还是使用了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添加键值对
关键步骤
- 计算key的hash值，计算槽位置
- 如果没有hash碰撞，则直接放入桶中
- 如果hash碰撞，key不同，则放到链表末尾，key相同则覆盖value值
- 如果链表长度大于等于8则链表转换成红黑树（计算链表长度不包含槽位上的节点）
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//hash算法计算key的hash值
static final int hash(Object key) {
int h;
//key可以为null,当key为null时，返回0
// >>>:无符号右移 h >>> 16 将高16位移到低16位；^:异或运算,异或运算能更好的保留各部分的特征
//key不为null，将key的hashcode无符号右移16位后做异或运算,将高低位二进制特征混合起来
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//onlyIfAbsent 如果当前位置已存在一个值，是否替换，false是替换，true是不替换
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab:存储节点； p:当前槽位的节点值；n:hash桶容量大小；i:当前槽位的索引
Node<K,V>[] tab; Node<K,V> p; int n, i;
//将成员变量hash桶赋值给tab，为了节省内存空间，实例化HashMap时，hash桶为null,在第一次 //添加元素时会为Hash桶扩容。
if ((tab = table) == null || (n = tab.length) == 0)
//通过resize进行扩容
//将扩容后的hash桶容量赋值给n
n = (tab = resize()).length;
//(n-1)&hash:计算槽位，为了让哈希后的结果更加均匀；如果当前槽位没有数据，则直接将当前值放入 //这个槽位
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//比较hash值和key值确认是否key相同，如果相同，则直接覆盖value值，所以HashMap中的key不 //能重复
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//判断当前节点是否是TreeNode类型
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//key值不相等，则遍历链表
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果链表长度大于等于8则链表转化为红黑树（计算链表长度时不包含槽位上的节点）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//比较链表中是否存在key值相等的，如果有相同的key则跳出当前循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果e不当与null，表示槽位上或链表中有key值相同的节点，覆盖原先的value值
if (e != null) { // existing mapping for key
V oldValue = e.value;
//onlyIfAbsent 如果当前位置已存在一个值，是否替换，false是替换，true是不替换
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//更新
++modCount;
//扩容判断
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
final Node<K,V>[] resize() {
//将hash桶赋值给oldTab
Node<K,V>[] oldTab = table;
//获取hash桶的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//扩容阈值赋值
int oldThr = threshold;
//newCap:hash桶新的容量；newThr:新的扩容阈值
int newCap, newThr = 0;
//如果原先hash桶的容量大于0
if (oldCap > 0) {
//如果原先hash桶的容量大于等于最大值
if (oldCap >= MAXIMUM_CAPACITY) {
//将扩容阈值设置为最大，后续扩容判断时就不会进行扩容
threshold = Integer.MAX_VALUE;
return oldTab;
}
//hash桶原先容量扩大一倍赋值给newCap，如果扩容后的容量小于MAXIMUM_CAPACITY
//并且原先容量比16大
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//原先的扩容阈值扩大一倍作为新的扩容阈值
newThr = oldThr << 1; // double threshold
}
//如果原先扩容阈值大于0
else if (oldThr > 0) // initial capacity was placed in threshold
//将原先扩容的阈值作为新的hash桶容量
newCap = oldThr;
else {
// 将默认大小16作为hash桶容量
newCap = DEFAULT_INITIAL_CAPACITY;
//计算扩容阈值：16*0.75=12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的扩容阈值为0
if (newThr == 0) {
//计算扩容阈值：新容量*扩容因子
float ft = (float)newCap * loadFactor;
//新容量和扩容阈值都比MAXIMUM_CAPACITY小，则将ft作为新的扩容阈值否则将 //Integer.MAX_VALUE作为新的扩容阈值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//重新赋值成员变量扩容阈值
threshold = newThr;
//创建一个新的hash桶
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将新的hash桶赋值成员变量table
table = newTab;
//将原先hash桶的值转移到新的hash桶中
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;
}
}
}
}
}
//返回最新的hash桶
return newTab;
}
HashMap和HashTable的区别
| HashMap | HashTable | |
|---|---|---|
| 线程安全 | 线程不安全 | 线程安全 |
| 默认初始化大小 | 16 | 11 |
| 继承的父类 | AbstractMap | Dictionary |
| 是否允许null | key、value都能为null | 不能 |
| 扩容大小 | 原来的容量*2 | 原来的容量*2+1 |
| 解决hash冲突 | 链地址法+红黑树 | 链地址法 |
补充：
解决hash冲突的方式：
1.开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）
2.再哈希法
3.链地址法(Java hashmap就是这么做的)
4.建立一个公共溢出区
扫一扫
592
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
