总结HashSet以及分析部分底层源码
1. HashSet继承的抽象类和实现的接口
- 继承的抽象类：AbstractSet
- 实现了Set接口
- 实现了Cloneable接口
- 实现了Serializable序列化接口：该接口标记此类支持序列化操作
2. HashSet底层数据结构
HashSet底层是基于HashMap实现的，HashMap底层数据结构是基于数组+链表实现的。
1. 特点
- 既保存了数组查询和修改元素效率快的优点，也保存了链表在添加和删除元素时效率快的特点。
- 存储的元素是无序的，不允许重复的，存储的元素最多只能有一个为null值，这是因为HashSet底层存储元素时只是利用了HashMap的key来存储元素，而HashMap的value都是存储的 一个new Object() 对象。所以说HashSet只是利用了HashMap的key，并没有利用HashMap的value。
2. HashSet的底层结构图
因为HashSet底层是使用的HashMap，所以下图实际上是HashMap的底层数据结构。当存储一个元素时，首先会给这个元素计算一个hash值。然后根据计算出来的hash值决定将元素存储到哈希表中的那个位置。
3. 优点
- 存取效率高，可以动态扩容
4. 缺点
- 每次存储新的元素都需要计算一次hashCode值，如果计算hash值的算法设计的不好，哈希碰撞产生过多，就可能造成一个节点小存储了多个元素，而哈希表中相邻的元素的位置没有存储任何元素。
- HashSet线程不安全，在多线程情况下会出现线程安全问题。
3. HashSet适用的场景
-
需要存储不重复的值，要求存取效率高，适合在单线程情况下使用。
-
如果需要在多线程情况下使用，需要使用Collections集合工具类，创建一个线程安全的HashSet集合
Set<Integer> hashSet = Collections.synchronizedSet(new HashSet<Integer>());
4. HashSet底层源码分析
1. 构造函数
1. 默认无参构造函数
/**
* 默认无参构造函数
*/
public HashSet() {
map = new HashMap<>();
}
2. 传递一个集合的构造函数
/**
* 可以将集合中的数据全部添加到新创建的HashSet集合中，会去除掉重复的值。
* @param c
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
2. 添加一个元素的流程
1. 将数据包装
在每次添加数据时，如果数据是基本数据类型，会先将基本数据类型进行装箱操作，把基本数据类型转换成对应的包装类型（引用数据类型）
// 例如：集合中存放Integer数据类型，在进行add操作时，会先进行装箱操作
/**
* 将基本数据类转换为引用数据类型
* @param i 传入的参数为一个基本型数据类型
* @return 返回的参数是一个基本数据类型的包装类（引用数据类型）
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
2. 调用add() 方法
/**
* HashSet的添加方法
* @param i 传入需要添加的元素
* @return 添加成功返回true，失败返回false
*/
public boolean add(E e) {
// 直接调用已经创建好的HashMap集合，调用HashMap中的put()方法进行添加，key为元素值，value为常量对象
return map.put(e, PRESENT)==null;
}
-
常量说明
// 该常量对象将作为HashSet集合的value private static final Object PRESENT = new Object();
3. HashMap中的put()方法
/**
* HashMap的put添加方法
* @param key 对应的是HashSet要添加的元素
* @param value 对应的是一个常量对象 new Object()
* @return 添加成功返回null，添加失败返回value值
*/
public V put(K key, V value) {
// 调用putVal()方法，对元素进行添加
return putVal(hash(key), key, value, false, true);
}
4. HashMap中的hash()方法
/**
* HashMap的hash方法，用于计算每个key的hash值，这个hash值将决定key在哈希表中的具体位置
* @param key 对应的是HashSet要添加的元素
* @return 返回根据key计算出来的hash值
*/
static final int hash(Object key) {
// 用于接收计算好的hash值
int h;
// 返回根据key计算出来的hash值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
5. HashMap中putVal()方法
/**
* HashMap的hash方法，用于计算每个key的hash值，这个hash值将决定key在哈希表中的具体位置
* @param hash 计算好的hash值
* @param value 需要存储的key值
* @param onlyIfAbsent 需要存储的value值
* @param onlyIfAbsent 如果返回true说明添加的key是首次添加，false说明是修改了对应key的value
* @param evict 目前HashMap并没有使用改变了，留给了实现HashMap的子类
* @return
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
// 创建一个类型为Node的数组，其实就是哈希表
Node<K,V>[] tab;
//
Node<K,V> p;
// 辅助n，记录tab的长度。辅助变量i，存储经过计算得到的tab表的下标值
int n, i;
// 判读tab表是否为空，或者长度为0，满足则说明是第一次创建tab表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // 为tab表创建初始大小16，赋给辅助变量n
// 将tab表长度减一在和hash进行按位与运算，得到一个tab表的下标值，赋给i，
// 再将当前下标所指向的tab表的对象赋给p，判断当前位置上是否存储对象，即是否为null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); // 如果当前位置为null，直接添加一个新节点
// 如果当前位置已经存储过节点
else {
// 创建一个节点对象e
Node<K,V> e;
// 创建一个与key相同类型的变量k
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是不是红黑树的一个节点对象
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // 作为节点添加到红黑树
// 如果table对应索引位置，已经是一个链表,就使用for循环比较
else {
/*
1. 依次和该链表的每一个元素比较后，都不相同,则加入到该链表的最后
注意在把元素添加到链表后，立即判断该链表是否已经达到8个结点,
达到8个节点数就调用treeifyBin()对当前这个链表进行树化(转成红黑树)
注意：
if(tab==null||(n=tab.length)<MIN_TREEIFY_CAPACITY(64))
resize();
如果上面条件成立，先table扩容，只有上面条件不成立时，才进行转成红黑树
*/
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
// 2. 依次和该链表的每一个元素比较过程中，如果有key相同情况,就直接break
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)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 记录集合被修改的次数
++modCount;
// 判断当前哈希表中实际存储的元素个数是否得到扩容条件，threshold的大小为哈希表长度的0.75（默认值）
if (++size > threshold)
resize(); // 调用扩容方法
afterNodeInsertion(evict); // 该方法在HashMap中没有实际作用，是留给HashMap的子类的
return null; // 添加节点元素成功，返回null
}
