结论
- 1、HashSet底层是 一 HashMap
- 2、添加一个元素时,先得到hash值 -> 会转成 -> 索引值
- 3、找到存储数据表table,看这个索引位置是否已经存放的有元素
- 4、如果没有,直接加入
- 5、如果有,调用equals比较,如果相同,就放弃添加,如果不相同,则添加到最后
- 6、在Java8中,如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8),并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树)
- 7、HashSet底层是HashMap,第一次添加时,table数组扩容到16,临界值(threshold)是16 * 加载因子(loadFactor)是0.75 = 12
- 8、如果table数组使用到了临界值就是32 * 0.75 = 24,依次类推
- 9、在Java8中,如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8),并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树),否则仍然采用数组扩容机制。
示例代码
HashSet hashSet = new HashSet();
hashSet.add("夏天");
hashSet.add("夏天");
hashSet.add("悄悄过去");
hashSet.add("留下小秘密");
System.out.println(hashSet);
构造函数
//从这里可以看出HashSet底层其实就是一个HashMap
public HashSet() {
map = new HashMap<>();
}
//这是整个HashMap最妙的代码了
//他会找到比初始值大的离初始值最近的2的次方的数,给桶数组初始化
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
指定装载因子的值
//指定装载因子为0.75,后面桶数组到达75%就会进行扩容
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public boolean add(E e) 方法
//add带着要添加的值e和PRESENT调用put方法
//PRESENT起到的是一个占位的作用
//private static final Object PRESENT = new Object();
public boolean add(E e) {
//可以看出put如果返回null即添加成功,否则添加失败
return map.put(e, PRESENT)==null;
}
public V put(K key, V value); 方法
public V put(K key, V value) {
//先调用hash()方法去计算K的哈希值对应桶数组的索引值
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key);方法
static final int hash(Object key) {
int h;
//如果添加的值为null则返回0,不为null这调用hashCode()方法计算key的哈希值,然后无符号向右移16为,得到对应桶数组的索引值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
inal V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) 方法
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一定为空,所以会进入到 resize()方法中,给桶数组指定初始容量。
//resize()方法见下一个代码块
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
……
……
(中间省略一大段代码,后面再讲)
……
……
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
final Node<K,V>[] 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 &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//如果旧容量小于等于零,就把旧阈值赋值给新容量
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//如果旧容量和阈值都为零,也就是第一次添加数据的时候,指定新容量为16,新阈值为容量的75%
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
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;
//到此所有的参数都准备好了,开始new桶数组
@SuppressWarnings({"rawtypes","unchecked"})
//定义一个容量为newCap的新的桶数组
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)
newTab[e.hash & (newCap - 1)] = e;
//如果桶中为红黑树,则对树进行拆分
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
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;
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;
}
之后就是一步一步返回到add()方法,添加成功则返回true,失败则返回false。