本次博客带领大家了解集合中的Set接口实现类-HashSet，介绍HashSet的全面说明和源码分析。
HashSet的全面说明
- HashSet实现了Set接口。
- HashSet实际上是HashMap。
public HashSet() {
map = new HashMap<>();
}
- 可以存放null值，但是只能有一个null。
- HashSet不保证元素是有序的，取决于hash后，再确定索引的结果。(不保证存放元素的顺序和取出的顺序一致)
- 不能有重复元素/对象。
- 案例一:
public class HashSet01 {
public static void main(String[] args) {
HashSet set = new HashSet();
//1.在执行add方法后，会返回一个boolean值。
//2.如果添加成功，返回true，否则返回false。
//3.可以通过remove 指定删除哪个对象。
System.out.println(set.add("john"));
System.out.println(set.add("lucy"));
System.out.println(set.add("john"));
System.out.println(set.add("jack"));
System.out.println(set.add("Rose"));
set.remove("john");
System.out.println("set="+set);
}
}
- 案例二：
public class HashSet01 {
public static void main(String[] args) {
HashSet set = new HashSet();
set = new HashSet();
System.out.println("set="+set);
set.add("luck");
set.add("luck");
set.add(new Dog("tom"));
set.add(new Dog("tom"));
System.out.println("set="+set);
//在加深一下，非常经典的面试题。
set.add(new String("ld"));
set.add(new String("ld"));
System.out.println("set="+set);
}
}
class Dog{
private String name;
public Dog(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
'}';
}
}
HashSet底层机制说明
- 分析HashSet底层是HashMap，HashMap底层是(数组+链表+红黑树)。
- 模拟简单的数组+链表结构。
public class HashSetStructure {
public static void main(String[] args) {
//模拟一个HashSet的底层(HashMap的底层结构)
//1.创建一个数组，数组的类型是Node[]
//2.有些人，直接把Node[]数组称为表
Node[] table = new Node[16];
System.out.println("table="+table);
//3.创建节点
Node john = new Node("john",null);
table[2] = john;
Node jack = new Node("jack",null);
john.next = jack;//将jack节点挂载到john
Node rose = new Node("Rose", null);
jack.next = rose;
Node luck = new Node("luck", null);
table[3] = luck;//把luck放到table 表的索引为3 的位置。
System.out.println("table="+table);
}
}
class Node{
// 节点，存储数据，可以指向下一个节点，从而形成链表
Object item; //存放数据
Node next; //指向下一个节点
public Node(Object item, Node next) {
this.item = item;
this.next = next;
}
}
HashSet扩容机制和源码分析
- 分析HashSet的添加元素底层是如何实现的(hash()+equals())。
- HashSet 底层是 HashMap。
- 添加一个元素时，先得到hash值 - 会转成 ->索引值。
- 找到存储数据表table，看这个索引位置是否已经存放有元素。
- 如果没有，直接加入。
- 如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加到相同索引链表的最后。
- 在Java8中，如果一条链表的元素个数达到 TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)。
- HashSet的添加元素的源码分析：
1.执行 HashSet()
public HashSet() {
map = new HashMap<>();
}
2. 执行 add()
public boolean add(E e) {
return map.put(e, PRESENT)==null;//private static final Object PRESENT = new Object();
}
3. 执行 put() ,该方法会执行 hash(key) 得到key对应的hash值 算法h = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
public V put(K key, V value) { //key = "java" value = PRESENT
return putVal(hash(key), key, value, false, true);
}
4.执行 putVal
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)
// 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) // -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;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- 分析HashSet的扩容和转成红黑树机制：
- HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值(threshold)是16*加载因子(loadFactor)是16**0.75 =12
- 如果table数组使用到了临界值12，就会扩容到16* 2 = 32，新的临界值就是32*0.75 =24，依次类推。
- 在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就进行树化(红黑树)，否则仍然采用数组扩容机制。
public class HashSetIncrement {
public static void main(String[] args) {
/*
1. HashSet底层是HashMap，第一次添加时，table数组扩容到16，
临界值(threshold)是16*加载因子(loadFactor)是16**0.75 =12
2. 如果table数组使用到了临界值12，就会扩容到16* 2 = 32，
新的临界值就是32*0.75 =24，依次类推。
*/
HashSet hashSet = new HashSet();
// for (int i = 1; i <= 100; i++) {
// hashSet.add(i);
// }
// for (Object o :hashSet) {
// System.out.println(o);
// }
/*
在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8)，
并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就进行树化(红黑树)，
否则仍然采用数组扩容机制。
*/
for (int i = 1;i<= 12;i++){
hashSet.add(new A(i));
}
System.out.println("hashSet="+hashSet);
}
}
class A{
private int n;
public A(int n){
this.n = n;
}
@Override
public int hashCode() {
return 100;
}
}
- 当我们向hashSet增加一个元素 -> Node ->加入table，就算是增加一个size++
/*
当我们向hashSet增加一个元素 -> Node ->加入table，就算是增加一个size++
*/
for (int i = 1;i<= 7;i++){//在table的某一条链表上添加了 7个A对象。
hashSet.add(new A(i));
}
for (int i = 1;i<= 7;i++){//在table的某一条链表上添加了 7个B对象。
hashSet.add(new B(i));
}
HashSet的练习1
定义一个Employee类，该类包含:private成员属性name,age 要求：
- 创建3个Employee 对象放入HashSet中。
- 当name和age的值相同时，认为是相同员工，不能添加到HashSet集合中。
public class HashSetExercise {
public static void main(String[] args) {
/*
定义一个Employee类，该类包含:private成员属性name,age 要求：
1. 创建3个Employee 对象放入HashSet中。
2. 当name和age的值相同时，认为是相同员工，不能添加到HashSet集合中。
*/
HashSet hashSet = new HashSet();
hashSet.add(new Employee("milan",18));
hashSet.add(new Employee("smith",18));
hashSet.add(new Employee("milan",18));
for (Object o :hashSet) {
System.out.println(o);
}
}
}
//创建Employee
class Employee{
private String name;
private int age;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//如果name 和 age 值相同，则返回相同的hash值
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return age == employee.age &&
Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
HashSet的练习2
定义一个Employee类，该类包含:private成员属性name,sal,birthday(MyDate类型)，其中birthday为MyDate类型(属性包括:year,month,day) 要求：
- 创建3个Employee 对象放入HashSet中。
- 当name和birthday的值相同时，认为是相同员工，不能添加到HashSet集合中。
public class HashSetExercise2 {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add(new Employee1("milan",1800,new MyDate(2000,10,22)));
hashSet.add(new Employee1("smith",1800,new MyDate(2000,10,22)));
hashSet.add(new Employee1("milan",1800,new MyDate(2000,10,20)));
for (Object o :hashSet) {
System.out.println(o);
}
}
}
class Employee1{
private String name;
private int sal;
private MyDate birthday;
public Employee1(String name, int sal, MyDate birthday) {
this.name = name;
this.sal = sal;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSal() {
return sal;
}
public void setSal(int sal) {
this.sal = sal;
}
public MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Employee1{" +
"name='" + name + '\'' +
", sal=" + sal +
", birthday=" + birthday +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee1 employee1 = (Employee1) o;
return Objects.equals(name, employee1.name) &&
Objects.equals(birthday, employee1.birthday);
}
@Override
public int hashCode() {
return Objects.hash(name, birthday);
}
}
class MyDate{
private int year;
private int month;
private int day;
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MyDate myDate = (MyDate) o;
return year == myDate.year &&
month == myDate.month &&
day == myDate.day;
}
@Override
public int hashCode() {
return Objects.hash(year, month, day);
}
}
523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
