Java集合之Set接口
跟着韩老师学集合B站。
1. Set
1.1 特性和实现子类
- 存放数据是无序的，不包含索引；取出的顺序和添加的顺序不同，但是取出的顺序是固定的。
- 不允许元素重复，至多包含一个
null； - 实现的接口有：
AbstractSet，ConcurrentHashMap.KeySetView，ConcurrentSkipListSet，CopyOnWriteArraySet，EnumSet，HashSet，JobStateReasons，LinkedHashSet，TreeSet。
常用方法和实现了Collection接口的其它相似，可以参考上一篇博客。
1.1 HashSet
实际上研究
HashSet的源码就是研究HashMap的源码。
1.1.1 底层实现结构
根据
HashSet的构造函数可以明显看出它的底层是由HashMap实现的。并且HashMap的底层是：数组+链表+红黑树。
public HashSet() {
map = new HashMap<>();
}
这里简单的实现一下数组+链表： 如果将全部的数据都放到数组里面，效率会很低，如果使用数组+链表实现存储效率会很高。
/**
* @Description HashSet结构简单模拟，其实就是HashMap
* @date 2022/4/2 13:33
*/
public class HashSetStructure {
public static void main(String[] args) {
// 存放数据的数组
Node[] table = new Node[16];
Node john = new Node("john",
new Node("jack",
new Node("rose",null)));
table[2] = john;
Node lucy = new Node("lucy", null);
table[3] = lucy;
}
}
class Node{
Object item;
Node next;
public Node(Object item, Node next){
this.item = item;
this.next = next;
}
}
执行上方代码后的结构情况：即数组中存放一个“头”节点，使用next指向下一个节点。
1.1.2 添加元素和扩容机制
添加：
// 统一在调用map的put方法时value是object
private static final Object PRESENT = new Object();
/**
* 添加元素
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
/**
* hashMap中put方法：添加元素到map中
* key 键——add方法的值
* value 值——默认的object对象
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* 根据传入key的hashCode按位异或右移16位计算出hash值，目的是减少hash冲突。
* @param key add方法传入的值
* @return hash code
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// 在HashMap中存放node节点
transient Node<K,V>[] table;
/**
*
* @param hash 计算出的hash值
* @param key 传入的key
* @param value 传入的value
* @param onlyIfAbsent
* @param evict 由子类去实现
* @return
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 辅助变量tab，针对全局变量table做出处理
HashMap.Node<K,V>[] tab;
// 辅助变量p，
// 如果hash值不相同：记录当前传入的hash值在作为在数组中的变量
// 如果hash值相同：就记录已经存储在table中的节点。
HashMap.Node<K,V> p;
// 辅助变量n，存储数组长度
int n;
// 辅助变量i，存储计算之后要存储的数组索引下标值
int i;
// table为空或者tab长度为0，就代表第一次添加，要进行扩容。
if ((tab = table) == null || (n = tab.length) == 0)
// resize()方法返回一个数组空间，请看下个代码块。
n = (tab = resize()).length;
// 根据新入的hash值在table的哪个索引位置存放，并把位置对 象赋值给辅助对象p
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果p为空，表示没有存放数据，就创建一个新的节点。
tab[i] = newNode(hash, key, value, null);
else {
HashMap.Node<K,V> e;
// 辅助变量，存储准备添加元素的key
K k;
// 对应下图情况A
// 如果当前索引位置对应链表的第一个元素与准备添加的新元素的的key的hash值一样
// 并且新元素的key和已经存在与table中节点的key相同 或者 他们的内容相同
// 就认为新元素不能够添加
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 判断 p 是不是红黑树节点对象
// 是就按照红黑树进行添加，人菜就不看了
else if (p instanceof HashMap.TreeNode)
e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 对应下图情况B
// 链表情况
// 循环遍历链表
for (int binCount = 0; ; ++binCount) {
// 直到比较到链表的最后一个节点仍然不相同；添加成功是e的值为null
if ((e = p.next) == null) {
// 直接将新节点链接到最后一个节点后面
p.next = newNode(hash, key, value, null);
// 如果比较次数大于等于临界点减一（ 8 - 1 ），即当前元素已经是第临界点个元素：
// 调用树化方法，树化方法中会对table长度进行判断：
// 长度小于64会进行扩容；只有大于等于64才会进行树化
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
// 对应下图情况C
// 如果新元素，与当前索引的链表中某个节点相同，认为当前元素不可添加
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果添加失败，返回要添加的值
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 替换为新的value
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 修改次数++
++modCount;
// 判断添加之后的大小是否超过了12
if (++size > threshold)
// 执行扩容
resize();
// 由子类去实现，在HashMap中并没有实现。
afterNodeInsertion(evict);
// 添加成功就返回空
return null;
}
第一次添加过程：
正常添加过程相较于上图忽略开辟空间过程。
添加数据hash值相同情况：
- 情况A
- 情况B
- 情况C
开辟（扩容）方法，简写
/**
* 开辟一个存储node节点的数组空间
* @return node数组
*/
final HashMap.Node<K,V>[] resize() {
HashMap.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 &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else {
// 第一次添加时给定默认容量值
// static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; = 16
newCap = DEFAULT_INITIAL_CAPACITY;
// 临界值，如果已经用了容量的75%防止在最后没有空间时高并发访问。
// static final float DEFAULT_LOAD_FACTOR = 0.75f;
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数组空间
HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
// 将开辟的空间给map的全局遍历table
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
HashMap.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 HashMap.TreeNode)
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
HashMap.Node<K,V> loHead = null, loTail = null;
HashMap.Node<K,V> hiHead = null, hiTail = null;
HashMap.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;
}
}
}
}
}
// 返回开辟的空间
return newTab;
}
HashSet添加数据过程：
- 将元素的hash值转换成索引值；
- 找到数据存储表table，看索引位置是否已经存放元素；
- 没有直接加入；有就调用
equals比较，相同放弃，不同放弃到最后； - 再Java8中如果一条链表元素的个数到达
TREEIFY_THRESHOLD(默认值8)，并且table大小大于等于MIN_TREEIFY_CAPCCITY(默认值64)，就会转化为红黑树。
尽力了，可能现阶段能力就到此了。
不积小流，无以成江海。
1.2 LinkedHashSet
是
HashSet的子类，底层是一个LinkedHashMap，底层维护了一个数组+双向链表，它根据HashCode值来决定元素的存储位置，使用双向链表来维护元素的次序，看似是以插入顺序保存的。不允许添加重复元素。
1.2.1 底层存储
LinkedHashMap实现了一个数组+双向链表，双向链表保证顺序，该双向链表有头节点head
和位节点tail。
LinkedHashSet<String > linkSet = new LinkedHashSet<>();
linkSet.add("d");
linkSet.add("b");
linkSet.add("a");
// 假设 x 的 hash值 和 a 的相同
linkSet.add("x");
实例化LinkedHashSet：创建LinkedHashMap
/**
* 调用父类的构造方法
* @param initialCapacity table长度16
* @param loadFactor 临界值 = table长度 * .75
* @param dummy true
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
创建完成的LinkedHashMap中包含：
// 数组table(使用父类HashMap中的table)
transient Node<K,V>[] table;
// 头节点
transient LinkedHashMap.Entry<K,V> head;
// 尾节点
transient LinkedHashMap.Entry<K,V> tail;
节点类：继承自HashMap.Node
static class Entry<K,V> extends HashMap.Node<K,V> {
// 指向前节点和后节点。
Entry<K,V> before, after;
// 调用node的构造方法，只有next节点。
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
后面的添加和扩容逻辑实际上也是调用的HashMap中的putVal()方法，请参考上面。没找到在哪指定的before和after，不得不感叹JDK coder牛逼。
TreeSet在后面与TreeMap重写一篇新文章。