七、HashSet底层详解

特点

• 无序、无索引

• 不可重复(地址)，可存一个null

• 不可用索引取出

• 存放和取出顺序不一定一样

• 但每次取出的顺序是一样的

• 遍历只能迭代器和增强for

• 底层其实是HashMap

结论

源码解读

构造器

HashSet hs = new HashSet();底层实现

可见底层HashSet底层就是HashMap；

添加元素

hs.add(“1”)底层实现

1. 首先进入add方法
   
   相当于map添加元素e就是我们存的值，PRESENT是底层统一提供的value，因为map是需要key-value的，但我们只需要使用这里的key，所以value我们不用管
2. add方法调用put方法进行存值
   我们知道，HashSet是无序的，底层的排列方式是按照Hash值进行排列的，所以先进入hash(key)进行Hash值的计算
3. 进入hash(key)进行hash值的计算
   
   这里就可以看到hash值的计算方法，如果传进来null的话，hash值直接为0，不为null的话，得到key的hashCode(hashCode是Object的方法，每个对象都会有自己的hashCode)，再右移16位。
4. 这是String类型的hashCode计算
   我们自己写的类，hashCode就由我们自己定义
5. 好hash值算好，我们回到第二步的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;//设置一些辅助变量
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
            /*
            	1.table就是map的属性，是一个数组，即存的内容
            	2.(tab = table) == null || (n = tab.length) == 0
            		这就是先tab = table然后判断是否为空或者长度为0
            	3.如果表中没有数据，就resize()重新设置表的长度，见resize讲解
            */
            
            
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
            /*
            	p = tab[i = (n - 1) & hash]：p指向tab数组将要保存的数据位置，
            	位置就是按照得到的hash值i = (n - 1) & hash再经过这样的计算
            	判断这个位置是否为null即这个位置是否保存了数据
            	如果没保存的话，就直接保存在这个位置
			*/
        else {
        	/*
            	否则就说明那个位置有数据了，就要考虑以下两点
            	1. 是否相同（和其中任意一个已有数据相同，就直接替换。注意这里的相同判断是equals方法，大部分equals方法是需要我们程序员自己定义的）
            	2. 往后添加是链型添加还是树形添加
					hashmap底层添加原理
					当该位置有数据，就以链表形式添加在最后
					但要考虑，如果链表后缀到达8时，并且表长超过64，链表就变成红黑树的形式保存，如果如果链表后缀到达8时，并且表长没有超过64，则还是添加在最后，与此同时表长变成原来2倍。
			*/
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //这里判断是否equals相同
                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) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //以上的三个判断，就是找到新数据需要添加的位置，如果找到位置应该是放在最后的，e就是null，因为最后就是空嘛，，如果找到了相同元素，这是e就不是空了，就走下面的个方法
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)//开头传入的参数flase，说明冲突时会进行替换操作
                    e.value = value;
                afterNodeAccess(e);//子类实现，这里不实现
                return oldValue;
            }
        }
        ++modCount;//改变次数记录
        if (++size > threshold)//看当前size是否超过扩容边界，如果超过，就要进行resize
            resize();
        afterNodeInsertion(evict);//这个方法是空方法，我们不用管，这个是留给hashset子类需要的话去实现的
        return null;
    }

• 5.1 resize讲解
  这里就不细讲了，可以参考别人写的https://juejin.cn/post/7035613144047157279
  代码整体框架：

首先进行新的容量确定

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//先把表表赋值给oldTab
        int oldCap = (oldTab == null) ? 0 : oldTab.length;//判断原来的表是否为null并赋值
        int oldThr = threshold;//原来扩容界限
        /*hashmap并不是装满再扩容的，而是到达75%容量时，进行扩容，所以这里保存一下原来的扩容界限*/
        int newCap, newThr = 0;//新的容量和扩容界限先定义为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
        //当没有容量且，边界值>0 时，说明边界值初始化过，就将新表容量等于边界值
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
        	/*
				一开始为null时，就走到这里进行初始化
				DEFAULT_INITIAL_CAPACITY = 1 << 4即newCap一开始赋值为16
				DEFAULT_LOAD_FACTOR = 0.75即扩容临界值为容量的0.75倍
			*/
            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;
        @SuppressWarnings({"rawtypes","unchecked"})
        /*
        	上面，就是新表大小以及新的边界值都设置好了
        	接下来开始转移数据
        */
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;//将新的容量表赋值给table
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {//遍历原来的表
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {//不为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;
    }

小结说明

1. 底层是hashmap
2. 存入数据前先计算hash值，再存值
3. 存值，需要考虑，该位置是否重复，是否按链表存还是树存
4. 表长扩容是2倍
5. 加载因子是0.75，当添加的数据大于12时(无论怎么添加)，进行扩容
6. 长度大于8时(且表长大于等于64时)转换为红黑树，小于6时退化为链表

练习(重要*掌握)

定义一个Employee类，该类包含:private成员属性name.age
要求:1.创建3个Employee对象放入HashSet中
2.当name和age的值相同时，认为是相同员工,不能添加到HashSet集合中

之后写的时候会涉及到的


以上两个分别表示当name和age相同时，equals和hashcode返回true

import java.util.HashSet;
import java.util.Objects;

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 +
                '}';
    }

    @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);
    }
}
public class Test {
    @SuppressWarnings({"all"})
    public static void main(String[] args){
        HashSet hs = new HashSet();
        hs.add(new Employee("xiaoming",12));
        hs.add(new Employee("wanggang",18));
        hs.add(new Employee("xiaoming",12));
        //如果不重写equals和hashcode的话，就会按照默认的equals和hashcode执行
        //就会有存入三个值
        //我们重写了之后，就会按照我们的给出equals和hashcode，这时，就会存入两个值
        System.out.println(hs);
    }
}

思考

定义一个Employee类，该类包含:private成员属性name,sal,birthday(MyDate类型)，其中 birthday为 MyDate类型(属性包括:year, month, day),要求:
1.创建3个Employee放入 HashSet中
2.当name和birthday的值相同时，认为是相同员工,不能添加到HashSet集合中