HashSet
HashSet(无序，唯一): 基于 HashMap 实现的，底层采用 HashMap 来保存元素
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
private transient HashMap<E,Object> map;//里面使用的是HashMap来实现HashSet的
private static final Object PRESENT = new Object();//一个虚设的 Value，用来补全HashMap里面缺失的value
public HashSet() {
map = new HashMap<>();
}
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));// HashMap 的默认负载因子，当 Map 被填满 75% 的时候，就会触发自动扩容
//16 是 HashMap 的默认最小初始容量。如果你的集合很小，那就按默认的 16 来
addAll(c);//将原来的元素加入里面
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);//允许自己设置扩容阀值
}
- HashMap 默认的初始化大小为 16。之后每次扩充，容量变为原来的 2 倍。并且， HashMap 总是使用 2 的幂作为哈希表的大小
- HashSet 就是一个把 Value 忽略掉、只用 Key 的 HashMap
HashMap
JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。
JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于等于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认大小
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认的负载因子
static final int TREEIFY_THRESHOLD = 8;//树化阈值，当一个“桶”里的链表长度达到 8 时，这个链表可能会转化为红黑树
static final int UNTREEIFY_THRESHOLD = 6;//当原本是红黑树的桶，由于删除了元素或者扩容拆分了桶，导致节点数降到 6 时，它会从红黑树退化回链表
static final int MIN_TREEIFY_CAPACITY = 64;//即便某个桶里的链表长度达到了 8，如果当前 HashMap 的总容量（数组长度）小于 64，它也不会把链表转成树，而是会优先选择扩容（resize）
这些是基础的静态变量
loadFactor 负载因子是控制数组存放数据的疏密程度，loadFactor 越趋近于 1，那么 数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，loadFactor 越小，也就是趋近于 0，数组中存放的数据(entry)也就越少，也就越稀疏
当原本是红黑树的桶，由于删除了元素或者扩容拆分了桶，导致节点数降到 6 时，它会从红黑树退化回链表
当一个“桶”里的链表长度达到 8 时，这个链表可能会转化为红黑树，即便某个桶里的链表长度达到了 8，如果当前 HashMap 的总容量（数组长度）小于 64，它也不会把链表转成树，而是会优先选择扩容（resize）
transient Node<K,V>[] table;//存储元素的数组，总是2的幂次倍
transient Set<Map.Entry<K,V>> entrySet;//一个包含了映射中所有键值对的集合视图
transient int size;//存放元素的个数，注意这个不等于数组的长度
transient int modCount;//每次扩容和更改map结构的计数器
int threshold;//阈值(容量*负载因子) 当实际大小超过阈值时，会进行扩容
final float loadFactor;//负载因子
这些是HashMap的关键元素！！！
static class Node<K,V> implements Map.Entry<K,V> {//键值对节点，还是链表形式的串起来
final int hash;
final K 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;
return o instanceof Map.Entry<?, ?> e
&& Objects.equals(key, e.getKey())
&& Objects.equals(value, e.getValue());
}
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);的原因是
-
h1 = 0xAAAA0001 (10101010 10101010 00000000 00000001)
-
h2 = 0xBBBB0001 (10111011 10111011 00000000 00000001)
这两个哈希值仅在高16位有区别，低16位完全相同，如果直接用 hashCode() 计算索引：
index1 = h1 & 15 -> 结果是 1、index2 = h2 & 15 -> 结果是 1->发生了冲突，但是实际上不是一个值，但是我们不用hashCode而是使用return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);就可以保证原始哈希码的高位信息和低位信息混合起来，让高位的差异也能影响到最终计算出的索引值。这极大地减少了因 hashCode() 实现不佳或 HashMap 容量较小而导致的哈希冲突，保证了键值对能更均匀地散列开，从而维持了 HashMap O(1) 的平均时间复杂度
因为这个^就将其混合起来了
这是HashMap存在的形式，一种链表，一种红黑树
// 默认构造函数。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
// 包含另一个“Map”的构造函数
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);//下面会分析到这个方法
}
// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 指定“容量大小”和“负载因子”的构造函数
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 ，在resize中再赋值给 newCap 进行table初始化
this.threshold = tableSizeFor(initialCapacity);
}
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);//防止 cap 本身就是 2 的幂
//numberOfLeadingZeros用来计算一个 32 位整数二进制表示中，开头连续的 0 的个数，然后-1>>>无符号右移(-1对应32个1),这样就可以计算出比cap大的最大的2的幂了
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
这就是扩容机制，传入的 initialCapacity 并不是最终的数组容量。HashMap 会调用 tableSizeFor() 将其向上取整为大于或等于该值的最小 2 的幂次方，并暂时保存到 threshold 字段。真正的 table 数组会在第一次扩容（resize()）时才初始化为这个大小
以 cap = 10 为例：
- 计算的第一步是 cap - 1=9，9 的二进制是: 00000000 00000000 00000000 00001001，numberOfLeadingZeros(9) 函数会计算这个二进制数从左边数起，有多少个连续的 0，结果就有28个
- 然后使用逻辑右移>>> (对于-1->也就是32个1)，移动后：00000000 00000000 00000000 00001111，对应十进制的15
- 15 + 1=16,也就是一个2的幂(>=initialCapacity的最小2的幂)
这个过程确保了无论你输入什么数字，HashMap 的容量总是一个2的幂，这对于它后续进行哈希计算和数据存储时的效率至关重要
putVal函数
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)
//(n - 1) & hash 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中(此时，这个结点是放在数组中)
tab[i] = newNode(hash, key, value, null);
else {//桶里面已经有了元素，就会发生hash冲突了
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//key一样就直接覆盖value
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);//只有当数组长度大于或者等于 64 的情况下，才会执行转换红黑树操作，以减少搜索时间。否则，就是只是对数组扩容。
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;
}
这个方法的目的是将一个键值对（key-value pair）放入哈希表中。
afterNodeAccess、afterNodeInsertion、afterNodeRemoval等钩子方法都是等待子类进行重写的，从而方便子类在不修改父类核心逻辑的情况下，扩展出“有序性”或“缓存淘汰”等高级功能
第一步：检查哈希表是否为空（懒加载）
if ((tab = table) == null || (n = tab.length) == 0)，HashMap 的懒加载机制。当你 new HashMap() 时，内部的数组（桶）并不会立即创建只有在第一次调用 put 时，这个 if 判断才会成立。它会调用 resize() 方法进行初始化，创建出初始容量的数组（通常是16），并把数组长度 n 赋值好
第二步：计算索引，并检查桶是否为空
if ((p = tab[i = (n - 1) & hash]) == null)，(n - 1) & hash 这个位运算，快速计算出给定的 key 应该存放在数组的哪个位置（哪个桶）
-
桶为空 - 直接插入——tab[i] = newNode(hash, key, value, null);
-
桶不为空 - 发生哈希冲突
- if (p.hash == hash && ((k = p.key) == key || ...))检查桶里面的key是不是和我们插入的k一样，如果一样直接value覆盖
- else if (p instanceof TreeNode)如果是一个树节点，那么就需要使用红黑树的方式来插入数据了，直接调用 putTreeVal 方法，把新节点插入到树中
- else { for (int binCount = 0; ; ++binCount) { ... } }从头到尾遍历这个链表，检查链表中的每个节点的 key 是否和要插入的 key 相同。如果找到了，就跳出循环，后续会更新它的 value；如果遍历到了链表的末尾 (p.next == null) 还没找到相同的 key，说明这是一个全新的元素。就把它创建一个新节点，追加到链表的末尾。
- 在追加新节点后，会检查当前链表的长度（binCount）是否达到了树化的阈值，如果到了那么就需要调用 treeifyBin 方法，尝试将这条链表转换成红黑树
- if (++size > threshold) resize();检查扩容，看看需不需要进行扩容方法处理
resize函数
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 && //没超过最大值，就扩充为原来的2倍
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0)
// 创建对象时初始化容量大小放在threshold中，此时只需要将其作为新的数组容量
newCap = oldThr;
else {
newCap = DEFAULT_INITIAL_CAPACITY;//无参构造函数创建的对象在这里计算容量和阈值
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//扩容前的旧容量小于16，在这里计算新的resize上限
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);
//将红黑树拆分成2棵子树，如果子树节点数小于等于 UNTREEIFY_THRESHOLD（默认为 6），则将子树转换为链表。
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;
//扩容后，容量翻倍。一个元素在新数组的位置要么在原位置，要么在原位置 + oldCap
if ((e.hash & oldCap) == 0) {
//在原来位置
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
//在原索引+oldCap处
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {// 原索引放到bucket里
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {// 原索引+oldCap放到bucket里
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
扩容函数是关键，也是最难的地方
第一部分：计算新容量和新阈值
第二部分：创建新数组并迁移数据
- Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];根据第一部分计算出的 newCap，在内存中创建一个新的、更大的数组
- table = newTab;: 将 HashMap 内部的 table 引用指向这个新创建的数组。从这一刻起，HashMap 开始使用新数组了
- if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { ... } }遍历旧数组 oldTab 的每一个桶，把里面的元素重新安置到新数组 newTab 中
- if (e.next == null)桶里面没有元素就直接放即可
- else if (e instanceof TreeNode)的元素太多，已经转成了红黑树。调用树节点专门的 split 方法——这个方法将一棵大树拆分成两棵小树，然后将这两部分分别放到新数组的两个不同位置
- else {...}将这条旧链表上的所有节点，高效地拆分到新数组的两个不同位置上(这是最难的地方)
if ((e.hash & oldCap) == 0)检查节点 hash 值的某一个特定位是 0 还是 1
Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null;创建了两条链表，lo来装判断结果为 0 的节点，hi判断结果为 1 的节点
- lo 链表（low低位链表）整体挂载到新数组的原索引 j 位置
- hi 链表（高位链表）整体挂载到新数组的原索引 + 旧容量” (j + oldCap) 位置
看上面的例子，就是这样子来挂的（但是这个ABCD的关系不一定对，这里是假设的hash值是0、1、0、1的结束的，所有才会分别挂在2长度的链表，实际上还是有可能一个链表挂四个节点的）
getNode函数
final Node<K,V> getNode(Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n, hash; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & (hash = hash(key))]) != null) {
if (first.hash == hash && //先检查hash值是不是一样的
((k = first.key) == key || (key != null && key.equals(k))))//然后再去比较数组桶里面的key是不是和我们需要找的key一样
return first;
if ((e = first.next) != null) {//不是就去找后面的链表
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);//后面如果是个红黑树就使用红黑树的方式来找
do {
//反之就用链表while的方式去后面一个一个找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;//找不到返回null
}
这个函数是来获取值的，获取的方式其实和前面的putVal很类似
- first = tab[(n - 1) & (hash = hash(key))先来获取到桶的位置
- first.hash == hash检查hash值是不是一样的，是就直接返回
- 不是就需要去找后面的链表
- 如果后面是TreeNode就需要使用红黑树的方式来找
- 反之就使用链表的方式来找
- 找不到才返回null
HashMap常见的方法
- put(K key, V value)：存入键值对。key 已存在则覆盖并返回旧值
- get(Object key)：根据 key 取值。找不到返回 null
- remove(Object key)：根据 key 删除记录。返回被删的值
- size()：返回当前键值对个数
- isEmpty()：判断是否为空
- clear()：清空所有数据
- containsKey(Object key)：常用。判断 key 是否存在（ O(1)复杂度）
- containsValue(Object value)：判断值是否存在（ O(n)复杂度，性能低）
- keySet()：返回所有 key 的 Set 集合
- values()：返回所有 value 的 Collection 集合
扫一扫
865
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
