Java集合-HashSet
HashSet（参考文章）
【介绍】
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
HashSet 是一个 没有重复元素 ，而且 无序 （存入和取出的顺序不一定相同）的集合。
它是由 HashMap 实现的，不保证元素的顺序，而且HashSet允许使用 null 元素。
【使用】
一、构造方法
// 默认构造函数
public HashSet()
// 带集合的构造函数
public HashSet(Collection<? extends E> c)
// 指定HashSet初始容量和加载因子的构造函数
public HashSet(int initialCapacity, float loadFactor)
// 指定HashSet初始容量的构造函数
public HashSet(int initialCapacity)
// 指定HashSet初始容量和加载因子的构造函数,dummy没有任何作用
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
二、API
Iterator<E> iterator()
int size()
boolean contains(Object o)
boolean add(E e)
Object clone()
boolean remove(Object o)
三、理解
-
HashSet 底层是 HashMap
-
添加 add 机制：
（1） 添加一个元素时，先得到 hash 值（索引值）
获取 hash 值的方法是：
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); // ^ 异或，>>> 无符号右移 }为什么要异或和右移:
> 异或 ^：因为&和|都会使得结果偏向0或者1 ,并不是均匀的概念,所以用 ^；
> 右移16位：高16位也参与运算，会让得到的下标更加散列
参考文章：https://blog.csdn.net/qq_36268103/article/details/119041390（2） 找到存储数据表 table ，看这个索引位置是否已经存放有元素：
若没有，直接加入；
若有，调用 equals方法比较，如果相同，则放弃添加；如果不相同，则添加到最后。 -
扩容机制：（由于HashSet底层就是HashMap，所以直接看HashMap的）
扩容实际调用的方法是： resize()
👇的图片例子代码为：
HashMap hashMap = new HashMap(); for (int i = 0; i < 12; i++) { hashMap.put(new A(i),"i"); } //A类重写了hashCode方法，使得他们的hash值是一样的（1）创建 HashMap对象时：
（2） 第一次添加时，table数组扩容到16，临界值（threshold）是 16 * 加载因子（loadFactor）是 0.75 = 12；
（3） 如果table数组使用到了临界值12，就会扩容到16 * 2 = 32，新的临界值就是 32 * 0.75 = 24，以此类推；
if (++size > threshold) resize(); //这里的 size 就是插入的结点数
（4）在Java8中，如果一条链表的元素个数到达 TREEIFY_THRESHOLD（默认是8），并且table的大小 >= MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树）,否则仍然采用数组扩容机制。
例子：假如有 12 个对象，它们的 hash值相同（转化的索引就相同），但是它们调用 equals方法显示各不相同。在 table数组上，当添加到第八个对象时，就会进行数组扩容（此时它们的索引会发生相应的改变，但还是相同），添加第九个对象时，也会进行数组扩容，这些对象仍然在同一个索引点的链表上。if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); //如果table长度小于常量MIN_TREEIFY_CAPACITY时，不会变为红黑树，而是调用resize()方法进行扩容。 -
遍历方式
由于 HashSet 是无序的，遍历方式常用的两种：
-
迭代器循环（快捷键
itit） -
增强 for 循环 （快捷键
集合名字.for）
-
【源码分析】
main方法执行的代码：
HashSet hashSet = new HashSet();
hashSet.add("java");
debug进去：
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
-
可以看到，若两个对象的hashCode相等，则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; //定义了辅助变量
//table 就是 HashMap 的一个数组， 类型是 Node[]
//if 语句表示如果当前 table 是 null，或者其大小=0
//就是第一次扩容，空间为16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//（1）根据key，得到hash 去计算该key应该存放到table表的哪个索引位置
//并把这个位置的对象，赋给 p
//（2）判断p 是否为 null
//（2.1）如果p 为null，表示还没有存放过元素，就创建一个Node（key="java",value=PRESENT）
//(2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null);
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果当前索引位置对应的链表的第一个元素和准备添加的 key 的 hash值一样
//并且满足以下两个条件之一：
//（1）准备加入的 key 和 p 指向的 Node 结点的 key 是同一个对象
//（2）p 指向的 Node 结点的 key 的equals（） 和准备加入的key比较后相同
//就不能加入
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//再判断 p是不是一棵红黑树
//如果是，就调用 putTreeVal方法 ，来进行添加
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果table对应索引位置，已经是一条链表，就是用for循环比较
//（1）依次和该链表的每一个元素比较后，若都不相同，就添加到链表的尾部
//注意：在把元素添加到链表后，立即判断该链表是否已经达到8个结点
//若是，则调用 treeifyBin 方法，对当前这个链表进行树化
//注意：在转成红黑树时，要进行判断，判断条件
//if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)【MIN_TREEIFY_CAPACITY 为64】
// resize();
//如果上面条件成立，先table扩容；
//只有上面条件不成立时，才进行树化
//（2）在比较过程中，如果有相同情况， 直接beak
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;
//这里的 size 是：每加入一个结点 Node （k,v,h,next），size++
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
HashSet的去重机制：hashCode()，equals()方法。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; //if 里面是判断头结点和传入的对象是否同一对象，
//或者是按程序员规定判断（equals方法）的相同对象
首先通过传入的对象的hashCode计算hash值，再通过hash值计算得到table表的索引，如果该索引处的头结点是空，直接插入，否则判断头结点的hash值和传入对象的hash值（判断是否同一对象：若两者的hash值都不同，那肯定是不同的对象，那就可以迅速判断 if 里面为 false；从而不需要再判断 &&后面的条件，提高了效率）。若hash值相同，则它们可能是同一对象，判断 ==，若相等，则整个if判断为true；若不相等，但是equals返回结果为true，也是判断它们相等，整个if为true。
【使用例子】
重点：理解添加机制
//如果当前索引位置对应的链表的第一个元素和准备添加的 key 的 hash值一样
//并且满足以下两个条件之一：
//（1）准备加入的 key 和 p 指向的 Node 结点的 key 是同一个对象
//（2）p 指向的 Node 结点的 key 的equals（） 和准备加入的key比较后相同
//就不能加入
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
从源码可以看到，若上面的if判断为 true，就会判断元素重复，不会进行插入操作
解决方法：重写 hashCode方法和 equals方法。
注意：是两个都要重写，原因是 &&
（1）若只重写了 hashCode方法，则equals方法返回的会是false，因为new 两个名字和年龄相同的雇员，它们也还是两个对象，默认调用的是Object类的，比较的是地址。如果是String类就行，他默认重写了equals方法
（2）若只重写了 equals方法，则它们的 hash肯定不同。
