目录
(1)putVal(hash,key,value,false,true)
二、LinkedHashSet（跟HashSet简单对比+图解）
前言
上一节结束了java集合的List篇 java集合之List篇——ArrayList补充和Vector、LinkedList的底层源码-CSDN博客
本节说一下Set篇——HashSet、LinkedHashSet、TreeSet的底层源码解析
一、HashSet（底层源码）
1.抛出问题
public class HashSet_Type {
public static void main(String[] args) {
HashSet<String> hashSet = new HashSet<>();
hashSet.add("java");
hashSet.add("php");
hashSet.add("java");
System.out.println(hashSet);//[java, php]
}
}为什么上面的代码最后的“java”没有加入到集合里面呢？数据怎么插入的？
public class HashSetType {
public static void main(String[] args) {
HashSet<A> hashSet = new HashSet<>();
for (int i = 0; i < 13; i++) {
hashSet.add(new A(i));
}
System.out.println(hashSet);
}
}
class A {
int a;
public A(int a) {
this.a = a;
}
@Override
public int hashCode() {
return 1000;
}
}
加入那么多条数据，hashSet里面的是怎么存储的，结构什么样？
2.先看结论
（1）插入数据机制
A. 先获取元素的哈希值（hashCode方法)
B. 对哈希值进行运算，得出一个索引值即为要存放在哈希表中的位置号
C. 如果该位置上没有其他元素，则直接存放如果该位置上已经有其他元素，则需要进行equals判断，如果相等，则不再添加。如果不相等则以链表的方式添加。
注意：这里的equals方法是每一个类都可以重写的，可以由程序员自己指定一定的规则判断。
String 方法的equals方法是java内置写好的，比较字符串的内容。
（2）扩容机制
A. HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值（threshold）是16*加载因子（loadFactor）是0.75=12
B. 如果table数组使用到了临界值12，就会扩容到16*2=32，新的临界值就是32*0.75=24，依次类推
C. 在Java8中，如果一条链表的元素个数到达TREEIFYTHRESHOLD（默认是8）并且table的大小>=MINTREEIFYCAPACITY（默认64），就会进行树化（红黑树），否则仍然采用数组扩容机制
3.两个重要方法
(1)putVal(hash,key,value,false,true)
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表的哪个索引位置
//并把这个位置的对象table[i]，赋给p
//(2)判断p是否为nuLL
//(2.1)如果p为nuLL，表示还没有存放元素，就创建一个Node（hash,key="java"，vaLue=PRESENT,next=null）
//(2.2)否则后面判断p即table[i]是否加入，以及要加入的位置（链表上还是红黑树上）
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//满足下面两个条件之一：
//（1）准备加入的key和p指向的Node结点的key是同一个对象
//（2）p指向的Node结点的key的equaLs（）和准备加入的key比较后相同
//就不能加入（即if条件成立）
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 {
//最后一种情况就是p是链表了，使用for循环比较
//（1）依次和该链表的每一个元素比较后，都不相同，则加入到该链表的最后
// 注意在把元素添加到链表后，立即判断该链表是否已经达到8个结点
// ，就调用treeifyBin（）对当前这个链表进行树化（转成红黑树）
// 注意，在转成红黑树时，要进行判断，判断条件
// if (tab == nuLl || (n =tab.length)<MIN_TREEIFY_CAPACITY(64))
// resize();数组扩容的方法
// 如果上面条件成立，先table扩容。
// 只有上面条件不成立时，才进行转成红黑树
//（2）依次和该链表的每一个元素比较过程中，如果有相同情况，就直接break
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // 判断该哈希桶是否到达8个
treeifyBin(tab, hash);//树化
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//处理出现相同数据对象的逻辑
//返回的东西不是null，代表添加数据失败
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 更新修改次数和大小
++modCount;
//如果集合的数据个数 大于 临界值（threshold=加载因子DEFAULT_LOAD_FACTOR*table长度）
// table扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
//返回null代表添加成功
return null;
}(2)resize()
/**
* 初始化或翻倍哈希表的大小。如果当前表为空(null)，则根据threshold字段中保存的初始容量目标进行分配。
* 否则，将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型，则需要拆分红黑树。如果是普通链表节点，则节点按原顺序进行分组。
*
* @return 新的哈希表
*/
final Node<K,V>[] resize() {
//将table给临时变量oldTab
Node<K,V>[] oldTab = table;
// 现有容量的大小，等于数组的长度，如果数组为空，返回0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 现有的扩容阈值
int oldThr = threshold;
// newCap表示新的容量，newThr新的扩容阈值
int newCap, newThr = 0;
// 如果现有容量大于0，表示已经初始化过了
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)
// 新的扩容阀值扩大为两倍，左移<<1 相当于乘以2
newThr = oldThr << 1; // double threshold
}
// 否则如果当前容量等于0 ，但是当前扩容阈值 > 0,调用有参构造函数会到这里
else if (oldThr > 0) // initial capacity was placed in threshold
// 进入这里，新的容量等于当前的扩容阈值，
newCap = oldThr;
// 否则如果当前容量等于0
else {
// 新的容量等于默认容量
newCap = DEFAULT_INITIAL_CAPACITY;
// 新的扩容阈值等于默认负载因子0.75*默认容量16=12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 如果新的扩容阈值等于0
if (newThr == 0) {
// 设置新的扩容阈值等于新的容量*负载因子
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 设置hashmap对象的扩容阈值为新的扩容阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 初始化数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
// 设置hashmap对象的桶数组为newTab
table = newTab;
// 下面是rehash的过程
// 如果旧的桶数组不为空，则遍历桶数组，并将键值对映射到新的桶数组中
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;
}4.源码解析
问题1解析：
hashSet的底层是hashMap,hashMap的底层是哈希表（桶数组）+哈希桶（链表或红黑树），基本的就是数组+单链表+红黑树
(1)添加第一个数据java（成功）
A.传入第一个数据时,先调用底层hashMap的put方法，将hash:对象存放数据的哈希值（ 跟原来数据对象的哈希值有所不同，这里的通过hash(数据对象)的方法的得到的一个哈希值 ）、key:数据对象、value:随便创建的一个Object对象（无意义）、false、true。这四个参数传入putVal()插入数据的方法。
B.执行putVal()方法，对数据对象进行，插入处理（前面的重要方法有注释说明），因为是第一次插入数据，哈希表这个桶数组是空的，长度还是0，进入到resize()方法进行扩容。
C. 执行resize()方法，记录旧的桶数组的容量和旧的临界值，更新新的桶数组的容量和临界值到临时变量newCap（第一次扩容这里是默认值16后面是2倍扩容）和newThr，再依靠新容量创建一个新的桶数组替换集合的桶数组，新的临界值替换集合的临界值。（如果旧的桶数组里面不为空，就是里面有数据，就执行下面的逻辑进行将数据拷贝到新的桶数组中，详情看上面的重要方法）
D.回到putVal()方法后，记录桶数组的长度n，通过(n-1)&hash的计算方法得到数据对象要插入到桶数组中的位置，如果该位置为空，就将数据对象放入到链表节点对象里面，将链表节点放到该桶数组的位置上。（如果该桶数组的位置不为空，即有数据，就要执行下面的逻辑，具体看上面的重要方法）
E.集合的操作次数和数据个数都+1，最后还要检查插入后数据个数是否大于临界值，判断是否需要扩容，这里不用。返回null代表插入数据成功。（putVal()方法有东西返回代表插入数据失败，afterNodeinsertion（）方法是一个空方法，不必理会）
(2)添加第二个数据php（成功）
与第一次插入数据的步骤相似，但有一个不同的地方：
就是在putVal()方法处理插入数据逻辑，在第一个if模块，桶数组并不是空的，有长度，所以不会有初始默认扩容。
(3)添加第三个数据java（失败）
A.传入的数据通过put方法进入putVal方法
B.进入到putVal()方法，不用默认扩容就到第二个if，用hash通过计算发现桶数组对应位置上有数据，走else模块的逻辑。进入else模块。
C.进入else模块，这个模块会先判断数据对象和哈希桶的头节点的数据对象是否地址或者equals一样(这里数据对象是String所以比较的是内容)。相同的话就返回一个不为空的东西，代表插入数据失败。不相同的话就进行下面两个模块，判断头节点是否是树根节点还是链表节点，后面要遍历树或链表，如果要添加的数据对象都和树或链表的数据都不同就插入数据，否则就返回一个不为空的东西，代表插入数据失败。
问题2解析：
这里只说和问题1不同的
前面的8次循环都和问题1的一样，因为类A的hashCode()方法被重写返回值都一样是1000，所以数据都插到同一个哈希桶上，循环8次后，该哈希桶上的链表长度已经达到链表的临界值8，后面再次插入数据会进行扩容或是树化。
注意：倍数扩容的情况：
（1）数据个数大于临界值(负载因子0.75*哈希表长度)
（putVal()方法中）
（2）哈希桶上的链表长度大于链表临界值（8） 并且 哈希表长度小于64
putVal()方法中
treeifyBin()方法中
第9次循环的哈希桶的链表长度超过链表临界值8，进入treeifyBin()判断是要扩容还是树化，最后扩容到32.
第10次循环扩容到64
最后一次循环的哈希表到达树化的临界值，开始树化。
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)//最后一次循环
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // 第9次和第10次循环进入这里
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;
}
}5.注意
A.上面并没有将红黑树的树化过程和倍数扩容过程中将树节点的内容拷贝到新的哈希桶中的过程，这两个过程进行详细讲解，这部分后面的Map篇会说到，这个过程更数据结构里面的差不多。
B.链表节点和树节点可以都放到哈希表中的原因：首先，链表节点就是哈希表的数据类型是可以直接存放的，(都是Node)。其次，树节点类型其实是Node类型的儿子的儿子，这里用到了多态。
二、LinkedHashSet（跟HashSet简单对比+图解）
LinkedHash是HashSet的子类，存放的数据都是不重复的，代码大部分公用。
不同点：
A.hash底层是哈希表+哈希桶（单链表或红黑树），而LinkedHashSet底层是哈希表+双向链表+红黑树（一个哈希桶上面的链表长度大于8并且哈希表长度达到64时）
B.hashSet是无序的，LinkedHashSet是有序的（双链表的原因）（插入的顺序）
C.LinkedHashSet的双向链表是贯穿整个集合的。如下图
三、TreeSet的使用
TreeSet是TreeMap的子类，添加数据也是 间接使用TreeMap的.put()方法，删除数据等也是一样。TreeSet是有序的，不重复的。 TreeSet底层维护的是一个红黑树，红黑树是一种自平衡的二叉树，因此TreeSet存储的数据是有序的。可以按照元素的大小顺序自动排序。
要实现TreeSet的自然排序就要给泛型限定的自定义类的对象之间设定比较规则，但是要如何设定呢？
以下有两个方法：
1.自定义类实现Comparable接口
示例代码：
import java.util.TreeSet;
// 自定义类 Person 实现 Comparable 接口
class Person implements Comparable<Person> {
private String name;
private int age;
// 构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter 方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
// 重写 compareTo 方法
@Override
public int compareTo(Person other) {
// 按年龄升序排列
return Integer.compare(this.age, other.age);
// 如果需要按名字排序，可以使用以下代码：
// return this.name.compareTo(other.name);
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
public class TreeSetExample {
public static void main(String[] args) {
// 创建 TreeSet 实例
TreeSet<Person> treeSet = new TreeSet<>();
// 添加 Person 对象
treeSet.add(new Person("Alice", 30));
treeSet.add(new Person("Bob", 25));
treeSet.add(new Person("Charlie", 35));
// 输出 TreeSet 中的 Person 对象
for (Person person : treeSet) {
System.out.println(person);
}
}
}运行结果：
2.匿名内部类方式实现comparator接口
示例代码：
// 自定义类 Person
class Person {
private String name;
private int age;
// 构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter 方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
public class ComparatorExample {
public static void main(String[] args) {
// 使用匿名内部类按年龄排序的 TreeSet
TreeSet<Person> ageSortedSet = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return Integer.compare(p1.getAge(), p2.getAge());
}
});
ageSortedSet.add(new Person("Alice", 30));
ageSortedSet.add(new Person("Bob", 25));
ageSortedSet.add(new Person("Charlie", 35));
System.out.println("按年龄排序：");
for (Person person : ageSortedSet) {
System.out.println(person);
}
// 使用匿名内部类按名字排序的 TreeSet
TreeSet<Person> nameSortedSet = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
});
nameSortedSet.add(new Person("Alice", 30));
nameSortedSet.add(new Person("Bob", 25));
nameSortedSet.add(new Person("Charlie", 35));
System.out.println("\n按名字排序：");
for (Person person : nameSortedSet) {
System.out.println(person);
}
}
}运行结果：
3.新建比较器类实现comparator接口
示例代码：
// 自定义类 Person
class Person {
private String name;
private int age;
// 构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter 方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
// 按年龄排序的比较器
class AgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return Integer.compare(p1.getAge(), p2.getAge());
}
}
// 按名字排序的比较器
class NameComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
}
public class ComparatorExample {
public static void main(String[] args) {
// 根据年龄排序的 TreeSet
TreeSet<Person> ageSortedSet = new TreeSet<>(new AgeComparator());
ageSortedSet.add(new Person("Alice", 30));
ageSortedSet.add(new Person("Bob", 25));
ageSortedSet.add(new Person("Charlie", 35));
System.out.println("按年龄排序：");
for (Person person : ageSortedSet) {
System.out.println(person);
}
// 根据名字排序的 TreeSet
TreeSet<Person> nameSortedSet = new TreeSet<>(new NameComparator());
nameSortedSet.add(new Person("Alice", 30));
nameSortedSet.add(new Person("Bob", 25));
nameSortedSet.add(new Person("Charlie", 35));
System.out.println("\n按名字排序：");
for (Person person : nameSortedSet) {
System.out.println(person);
}
}
}
300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
