HashSet
特点
- 允许元素为null
- 元素不可重复
- HashSet 实际上是 HashMap (数组+链表+红黑树)
- 不安全
- HashSet 不保证元素是有序的，取决于 hash 后，再确定索引的结果
HashSet 底层机制说明
HashSet 的底层实际就是 HashMap，HashMap 实际就是数组 + 链表 + 红黑树的结构。数组的每个索引位置默认存放的是单向链表，如果链表的长度到达了一个临界值就会转为红黑树。
解析
1.初始化HashSet
从源码得知，hashset进行初始化，实际上是初始化了一个hashMap。
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* default initial capacity (16) and load factor (0.75).
*/
public HashSet() {
map = new HashMap<>();
}2.初始化集合后，进行第一次add操作
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}PRESENT 主要起到占位作用，是一个空对象，用来代替 HashMap 中的 value
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
真正添加结点的操作是在 putVal 中执行的
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;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 定义辅助变量
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 1.如果当前表的引用为空或者是长度为空，则进入扩容方法
// 2.扩容会根据当前默认的长度16进行扩容，并且根据加载因子（0.75）得到临界值（12）
// 3.此时hash表的长度为16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 1.根据添加元素计算出来的hash值得到的数组的索引（`&`为按位运算符 就是得到两个值的二进制数后每个数进行 `&` 二进制数只有1或者0，进行比较时 1&1=1，1&0=0,0&0=0）
// 2.如果计算出来的索引值在table表中的值为空，则直接将元素的hash值，key，value添加到表对应的索引处。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 如果这个表中的索引对应的元素已存在
// 1.比较新元素的hash和表中索引的hash是否相等
// 2.并且 两个对象的key元素是否相等或者是说新元素的key不为空，并且
// 拿新元素的值（k）和表中存在的值（k）进行equals比较，在这里equals方法
// 怎样使用，完全由我们来控制，如果重写了equals就是比较对象的值，如果没有重写equals就是比较的对象的地址值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 如果两个元素相等，则将数组中索引的对象赋值。
e = p;
//不相等判断是链表还是红黑树
// 如果这个table表中已存在的元素，是一颗红黑树，则使用红黑树的方式进行元素的添加。
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 如果是一个链表
else {
for (int binCount = 0; ; ++binCount) { //循环读取链表
// 如果是一个链表，则进行循环读取，如果这个table索引处的链的节点下一个元素为空
if ((e = p.next) == null) {
// 如果下一个节点为空，直接将新结点添加到链表的末尾。
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果链表的节点长度 >=8
// 1.首先回去判断当前table表的长度是否是64，如果不是64
// 则会进行table表的扩容（当前容量+当前容量），并且计算出临界值
// 2.如果table表中此链表的长度 >=8 并且 table表的长度已经等于64
// 则将table表中的这个索引的链表转换成一颗红黑树
treeifyBin(tab, hash);
break;
}
// 如果在查询这条链表的过程中，发现链节点的元素的key和新元素的key相等，则不会添加，直接退出
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;
}final void treeifyBin(Node<K,V>[] tab, int hash) {
// 定义辅助变量
int n, index; Node<K,V> e;
// 判断数组是否为空，或者数组长度小于一个临界值（64）
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// 进行数组扩容，而不是转成红黑树
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
// 转红黑树的代码
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}判断元素是否已经存在，是否需要进行扩容，是否是红黑树结构，是否是链表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
- 如果当前表的引用为空或者是长度为空，则进入扩容方法
- 扩容会根据当前默认的长度16进行扩容，并且根据加载因子（0.75）得到临界值（12）
- 此时hash表的长度为16
final Node<K,V>[] resize() {
// 定义辅助变量
Node<K,V>[] oldTab = table;
// 旧数组长度 0
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; // double threshold
}
// 不满足条件
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 第一次扩容
else { // zero initial threshold signifies using defaults
// 新的数组长度默认为 16
newCap = DEFAULT_INITIAL_CAPACITY;
// 新的临界值默认为 12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 不满足条件
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) {
// 省略一大堆代码
}
// 返回新的数组
return newTab;
}if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
- 根据添加元素计算出来的hash值得到的数组的索引（`&`为按位运算符 就是得到两个值的二进制数后每个数进行 `&` 二进制数只有1或者0，进行比较时 1&1=1，1&0=0，0&0=0）
- 如果计算出来的索引值在table表中的值为空，则直接将元素的hash值，key，value添加到表对应的索引处。（代表当前HashSet的索引值中没有当前新节点索引，直接添加）
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
如果这个表中的索引对应的元素已存在
- 比较新元素的hash和表中索引的hash是否相等
- 并且 两个对象的key元素是否相等或者是说新元素的key不为空，并且拿新元素的值（k）和表中存在的值（k）进行equals比较，在这里equals方法
怎样使用，完全由我们来控制，如果重写了equals就是比较对象的值，如果没有重写equals就是比较的对象的地址值
3. table 数组扩容机制
final Node<K,V>[] resize() {
// 定义辅助变量
Node<K,V>[] oldTab = table;
// 旧数组长度 0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 旧临界值
int oldThr = threshold;
// 新的数组长度和临界值
int newCap, newThr = 0;
// 第 n 此扩容，n > 1
if (oldCap > 0) {
// 判断旧数组长度是否大于最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 新数组长度扩大两倍
// 并判断新数组长度是否 < 最大值，同时旧数组长度是否 >= 初始长度（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
// 新数组长度为旧数组长度临界值
// oldCap 为 0，因为如果 > 0 就走第一个条件了
newCap = oldThr;
// 第一次扩容
else { // zero initial threshold signifies using defaults
// 新的数组长度默认为 16
newCap = DEFAULT_INITIAL_CAPACITY;
// 新的临界值默认为 12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 判断是否新临界值为 0
if (newThr == 0) {
// 将新数组大小的 0.75 倍赋值给 ft
// 初始化 HashMap 时就指定了 loadFactor 为默认临界因子（0.75f）
float ft = (float)newCap * loadFactor;
// 如果新的数组大小 < 最大长度，并且 ft < 最大长度，新的数组长度临界值就为 ft
// 否则为整数的最大值
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)
// 没有下一个结点就直接将该结点移动到新数组上
// 注意：索引是由数组长度和 hash 值共同决定的
// 此时计算索引用的是新数组的长度，结果可能会与旧数组的索引不同
newTab[e.hash & (newCap - 1)] = e;
// 判断该索引位置是不是一个红黑树
else if (e instanceof TreeNode)
// 移动树上的结点
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 该索引位置是一个链表
else { // preserve order
// 定义 lowHead，lowTail，表示低位链表的头结点和尾节点
Node<K,V> loHead = null, loTail = null;
// 定义 hightHead，hightTail，表示高位链表的头结点和尾节点
// 低位链表和高位链表里的位，表示的是数组索引位
// 由于数组长度的增加，新数组的索引位置可能不变，也可能变大
// 如果不变，就用低位链表；如果变大，就用高位链表
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next; // 定义下一个结点
do {
// 获取下一个结点
next = e.next;
// 计算新新数组的索引位是否不变
if ((e.hash & oldCap) == 0) {
// 判断当前结点是否是头结点
// 因为最开始定义 loTail 为 null
// 而如果添加了一个结点后，loTail 就会指新的结点，不为 null
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;
}
扫一扫
1177
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
