Java基础 集合-Set之HashSet

Set接口的常用方法

和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样

Set接口的遍历方式

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口

1）可以使用迭代器

2）增强for

3)不能使用索引的方式来获取

//1.以set接口的实现类 HashSet来说明Set接口的方法
//2.set接口的实现类的对象（Set接口对象），不能存放重复的元素，可以添加一个null
//3.set接口对象存放的数据是无序（即添加的顺序和取出的顺序不一致）
//4.取出的顺序虽然不是添加的顺序，但是是固定的
//5.set对象不可以使用索引来获取

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
*    小黄debug
*/
public class SetMethod {
    public static void main(String[] args) {
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");    //重复数据
        set.add("jack");
        set.add(null);
        set.add(null);      //重复数据
        System.out.println(set);
        //迭代器
        System.out.println("================迭代器================");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println("obj = " + next);
        }
        System.out.println("================增强for================");
        for(Object o: set){
            System.out.println("o="+o);
        }
    }
}

HashSet的全面说明

1)HashSet实现了Set接口

2)HashSet实际上是HashMap

3)可以存放null值，但是只能有一个null

4)HashSet不保证元素是有序的，取决于hash后，再确定索引的结果

5)不能有重复元素/对象

import java.util.HashSet;
import java.util.Set;

/**
*    小黄debug
*/

public class HashSet_ {
    public static void main(String[] args) {
        /*
        1.构造器走的源码
        public HashSet() {
            map = new HashMap<>();
        }
        2.HashSet 可以存放null,但是只能有一个null,即元素不能重复
        */
        Set hashSet = new HashSet();
        hashSet.add(null);
        hashSet.add(null);
        System.out.println("hashSet = "+ hashSet);
    }

import java.util.HashSet;

/**
 * 小黄debug
 */
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"));//T
        System.out.println(set.add("lucy"));//T
        System.out.println(set.add("john"));//F
        System.out.println(set.add("jack"));//T
        System.out.println(set.add("Rose"));//T
        set.remove("john");
        System.out.println("set = "+set);//set = [Rose, lucy, jack]

        //
        set = new HashSet();
        System.out.println("set = "+set);
        //Hashset不能添加相同的元素/对象
        set.add("lucy");    //添加成功
        set.add("lucy");    //添加不了
        set.add(new Dog("tom"));    //添加成功
        set.add(new Dog("tom"));    //添加成功
        System.out.println("set = "+ set);
        //经典面试题
        set.add(new String("hsp")); //true
        set.add(new String("hsp")); //false
        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 + '\'' +
                '}';
    }
}

Set接口实现类HashSet

HashSet底层机制说明

分析HashSet底层是HashMap,HashMap底层是（数组+链表+红黑树）

/**
 * 小黄debug
 */
public class HashSetStructure {
    public static void main(String[] args) {
        //以debug方式进行查看各结点情况，数组里每个位置存放的实现是一个链表
        //模拟一个HashSet的底层（HashSet的底层是HashMap,HashMap的底层）
        //1.创建一个数组，数组的类型是Node[]
        //2.有些人直接把Node数组称为table
        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;

        Node rose = new Node("Rose",null);
        jack.next = rose;

        Node lucy = new Node("lucy",null);
        table[3] = lucy;

        System.out.println("table = " + table);

    }
}
class Node{
    //结点，存储数据，可以指向下一个结点，从而形成链表
    Object item;    //存放数据
    Node next;  //指向下一个节点

    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }
}

1.HashSet底层是HashMap
2.添加一个元素时，先得到hash值-会转成  ->  索引值
3.找到存储数据表table,看这个索引位置是否已经存放的有元素
4.如果没有，直接加入
5.如果有，调用equase比较，如果相同，就放弃添加，如果不相同，则添加到最后
6.在Java8中，如果一条链表的元素个数达到TREEIFY_THRESHOLD(默认是8)，
并且table的大小>= MIN_TREEIFY_CAPACITY(默认64)，就会进行树化（红黑树）

HashMap数据源码分析，此处暂时不涉及红黑树

import java.util.HashSet;
/**
 * 小黄debug
 */
public class HashSetSource {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("java");
        hashSet.add("php");
        hashSet.add("java");
        System.out.println("set="+hashSet);
        /*
        源码解读
        1.执行HashSet()
        public HashSet() {
            map = new HashMap<>();
        }
        2.执行add()
        public boolean add(E e) {   //e = "java"
             return map.put(e, PRESENT)==null;  //PRESENT => private static final Object PRESENT = new Object();
         }
         3.执行put(),该方法会执行hash(key)得到key对应的hash值 算法 h = key.hashCode()) ^ (h >>> 16)
         （这值并不是hashCode值，idea按Alt+Shift+F7可以进入到hash(key)）
         public V put(K key, V value) { //key = "java" value = new Object();这个value用来占位的
              return putVal(hash(key), key, value, false, true);
          }
        4.执行putVal
        final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
        boolean evict) {
            HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
            //table就是HashMap的一个数组，类型是Node[]
            //if语句表示如果当前table是空，或者大小==0
            //就第一次扩容到16个空间。
            if ((tab = table) == null || (n = tab.length) == 0) //n=表的长度，即数组空间的个数
                n = (tab = resize()).length;    //如果表空间长度为0，则进行扩容，默认初始扩容为16
            //（1）根据key,得到hash去计算该key应该存放到table表的哪个索引位置
            //并把这个位置的对象，赋给P
            //（2）判断p是否为null
            //(2.1)如果p为null,表示还没有存放过元素，就创建一个Node(key = "java",value = PRESENT
            //(2.2)就放在该位置table[i]
            if ((p = tab[i = (n - 1) & hash]) == null)      //i = (n - 1) & hash相当于i = hash % (n-1),是一个取余的过程
                tab[i] = newNode(hash, key, value, null);
            else {
                //一个开发技巧提示：在需要局部变量（辅助变量）时候，再创建是比较好的
                HashMap.Node<K,V> e; K k;
                //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
                //并且满足下面两个条件之一，准备加入的key和p指向的Node结点的key是同一对象
                //（1）准备加入的key和p指向的Node结点的key是同一对象
                //（2）p指向的Node结点的key的equalse()和准备加入的key比较后相同
                // 就不能加入
                if (p.hash == hash &&   //此时p是hash取余后的结点，hash值相同，接着比较key是否相同（排除key不为空）
                        ((k = p.key) == key || (key != null && key.equals(k)))) //k = p.key,将p的key值赋值给k
                    e = p;
                //再判断p是不是一颗红黑树
                //如果是一颗红黑树，就调用putTreeVal 来添加
                else if (p instanceof HashMap.TreeNode)
                    e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                //个人理解，如果索引所在位置第一个Node不相同，且不是链表，则比较索引所在位置的链表其他Node
                //如果没有相同的则添加到末尾，如果有相同的则返回该元素
                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==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;
//size就是我们每加入一个结点Node(k,v,h,next)
            if (++size > threshold)     //如果size 大于临界值（容器*3/4）
                resize();               //则这里进行扩容
            afterNodeInsertion(evict);  //这里什么都没做
            return null;
        }
         */
    }
}

HashSet底层机制说明

分析HashSet的扩容和转成红黑树机制

先说结论，再上代码

1.HashSet底层是HashMap,第一次添加时，table数组扩容到16，临界值(threshold)是16*加载因子

(loadFactor)是0.75 = 12

2.如果table数组使用到了临界值12，就会扩容到16*2 = 32，新的临界值就是32*0。75 = 24，依次类推

3.在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD     (默认是8），并且table的数据大小 >= MIN_TREEIFY_CAPACITY (默认64),就会进行树化（红黑树),否则仍然采用数组扩容机制

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

public class HashSetIncrement {
    public static void main(String[] args) {
        /*
        HashSet底层是HaspMap,第一次添加时，table数组扩容到16，
        临界值(threshold)是16*加载因子(loadFactor)是0.75 = 12
        如果table数组使用到了临界值12，就会扩容到16*2 = 32，
        新的临界值就是32 * 0.75 = 24,依次类推
         */

        //此处自行debug进行查看table的容器大小
        HashSet hashSet = new HashSet();
        for (int i = 0; i < 100; i++) {
            hashSet.add(i);
        }

        /*
        在Java8中，如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8)
        并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64),就会进行树化（红黑树），
        否则仍然采用数组扩容机制
         */
        HashSet hs = new HashSet();
        for (int i = 0; i <= 12; i++) {
            hs.add(new A(i));  //
        }
        System.out.println("hashset = " + hs);

        /*
        当我们向hashset增加一个元素， -> Node -> 加入table,就算是增加了一个,即size++
        当size达到临界值时，会进行扩容
         */
        HashSet hsy = new HashSet();
        for (int i = 1; i <= 7; i++) {
            hsy.add(new A(i));  //
        }
        for (int i = 1; i <= 7; i++) {
            hsy.add(new B(i));  //
        }
        System.out.println("hashset = " + hsy);

    }
}

class A{
    private int n;
    public A(int n){
        this.n = n;
    }


    @Override
    public int hashCode() {
        return 100;
    }
}

class B{
    private int n;
    public B(int n){
        this.n = n;
    }


    @Override
    public int hashCode() {
        return 200;
    }
}