20--Set集合

1、Set集合

1.1 Set集合概述

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。Set集合有多个子类：java.util.HashSet、java.util.LinkedHashSet、java.util.TreeSet

1.2 Set集合的特点

Set集合中的元素不可重复

Set集合没有索引

总结：不可重复性、无序性

2、HashSet集合

2.1 HashSet概述

HashSet 是 Set 接口的主要实现类，大多数时候使用 Set 集合时都使用这个实现类。

HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存储、查找、删除性能。

HashSet 具有以下特点：

不能保证元素的排列顺序
HashSet 不是线程安全的
集合元素可以是 null

HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法得到的哈希值相等，并且两个对象的 equals()方法返回值为true。

对于存放在Set容器中的对象，对应的类一定要重写hashCode()和equals(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

HashSet集合中元素的无序性，不等同于随机性。这里的无序性与元素的添加位置有关。具体来说：我们在添加每一个元素到数组中时，具体的存储位置是由元素的hashCode()调用后返回的hash值决定的。导致在数组中每个元素不是依次紧密存放的，表现出一定的无序性。

2.2 HashSet集合的特点

HashSet集合中的元素不可重复

HashSet集合没有索引

HashSet集合是无序的(存储元素的顺序与取出元素顺序可能不一致)

总结：不可重复性、无序性

2.3 HashSet常用方法

package com.suyv.set;

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

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 11:46
*@Description: HashSet常用方法
*/
public class HashSetDemo01 {
    public static void main(String[] args) {
        Set set = new HashSet();

        // 添加数据
        set.add("张三");
        set.add("lisi");
        set.add(null);
        set.add(new Date());
        set.add(10);

        // 遍历set
        for (Object obj : set) {
            System.out.println(obj);
        }

        // 删除数据
        set.remove("lisi");
        System.out.println(set);    // [null, Sat Dec 16 11:52:29 CST 2023, 张三, 10]

        // 获取长度
        System.out.println(set.size()); // 4

        // 判断非空
        System.out.println(set.isEmpty());  // false

        // 清空数据
        set.clear();
        System.out.println(set);    // []
    }
}

如何保证Hashset集合唯一？

底层依赖两个方法：hashCode()和equals()。

        步骤：

                首先比较哈希值

                如果相同，继续走，比较地址值或者走equals()

                如果不同,就直接添加到集合中

        按照方法的步骤来说：

                先看hashCode()值是否相同

                相同:继续走equals()方法

                        返回true：说明元素重复，就不添加

                        返回false：说明元素不重复，就添加到集合

                不同：就直接把元素添加到集合

如果类没有重写这两个方法，默认使用的Object()。一般来说一样。

而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。

2.4 HashSet存储自定义类型元素

2.4.1 案例1

定义Student类--不重写hashCode()和equals()

package com.suyv.set;

import java.util.Objects;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 11:55
*@Description: 实体类:Student
*/
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
        "name='" + name + '\'' +
        ", age=" + age +
        '}';
    }
}

定义测试类

package com.suyv.set;

import java.util.HashSet;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 11:59
*@Description: HashSet测试添加自定义实体类对象
*/
public class HashSetDemo02 {
    public static void main(String[] args) {
        //创建集合对象   该集合中存储 Student类型对象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存储
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(new Student("郭麒麟", 23));

        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}

结果：

2.4.2 案例2

定义Student类--重写hashCode()和equals()

package com.suyv.set;

import java.util.Objects;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 11:55
*@Description: 实体类:Student
*/
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    //不需要你手动重写Object  hashCode和equals ，再去测试
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

}

定义测试类

package com.suyv.set;

import java.util.HashSet;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 11:59
*@Description: HashSet测试添加自定义实体类对象
*/
public class HashSetDemo02 {
    public static void main(String[] args) {
        //创建集合对象   该集合中存储 Student类型对象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存储
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(new Student("郭麒麟", 23));

        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}

结果：

2.5 HashSet集合存储数据的结构

JDK的版本不同，HashSet集合的数据结构有所不同：

JDK8之前：数组+链表

JDK8之后：数组+链表+红黑树

以上数据结构我们称之为是哈希表

2.5.1 什么是哈希表

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。

3、LinkedHashSet

3.1 什么是LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，它是 链表和哈希表组合的一个数据存储结构。

3.2 LinkedHashSet集合的特点

LinkedHashSet 是 HashSet 的子类，不允许集合元素重复。

LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以添加顺序保存的。

LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。

3.3 LinkedHashSet常用方法

package com.suyv.set;

import java.util.Date;
import java.util.LinkedHashSet;
import java.util.Set;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 12:11
*@Description: LinkedHashSet常用方法
*/
public class LinkedHashSetDemo01 {
    public static void main(String[] args) {
        Set set = new LinkedHashSet();

        // 添加数据
        set.add("张三");
        set.add("lisi");
        set.add(null);
        set.add(new Date());
        set.add(10);

        // 遍历set
        for (Object obj : set) {
            System.out.println(obj);
        }

        // 删除数据
        set.remove("lisi");
        System.out.println(set);    // [张三, null, Sat Dec 16 12:21:11 CST 2023, 10]

        // 获取长度
        System.out.println(set.size()); // 4

        // 判断非空
        System.out.println(set.isEmpty());  // false

        // 清空数据
        set.clear();
        System.out.println(set);    // []
    }
}

4、TreeSet

使用元素的自然排序对元素进行排序或者根据创建set时提供的Comparable排序（定制排序）具体取决于你用的构造方法

4.1 TreeSet概述

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以按照添加的元素的指定的属性的大小顺序进行遍历。

TreeSet底层使用红黑树结构存储数据

新增的方法如下： (了解)

Comparator comparator()
Object first()
Object last()
Object lower(Object e)
Object higher(Object e)
SortedSet subSet(fromElement, toElement)
SortedSet headSet(toElement)
SortedSet tailSet(fromElement)

TreeSet特点：不允许重复、实现排序（自然排序或定制排序）

TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。

- 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
- 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。

定制排序：如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。

- 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
- 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。

因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象。

对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 或compare(Object o1,Object o2)方法比较返回值。返回值为0，则认为两个对象相等。

4.1 TreeSet自然排序

4.1.1 String类的自然排序

package com.suyv.set;

import org.junit.Test;

import java.util.Set;
import java.util.TreeSet;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 12:30
*@Description: TreeSet自然排序--String
*/
public class TreeSetDemo01 {

    @Test
    public void Test01(){
        Set set = new TreeSet();

        set.add("AA");
        set.add("BB");
        set.add("CC");
        set.add("DD");
        //set.add(123);  //报ClassCastException的异常

        System.out.println(set);    // [AA, BB, CC, DD]
    }
}

4.1.2 自定义类的自然排序

案例1

自定义实体类：User

package com.suyv.set;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 13:54
*@Description: 实体类User
*/
public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    public User(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 "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    // 比如：按照年龄从小到大排序
    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }

        if(o instanceof User){
            User u = (User)o;
            return this.age - u.age;
        }

        throw new RuntimeException("类型不匹配");
    }
}

TreeSet测试类

package com.suyv.set;

import java.util.Iterator;
import java.util.TreeSet;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 13:57
*@Description: TreeSet自然排序的使用
*/
public class TreeSetDemo02 {

    public static void main(String[] args) {
        TreeSet set = new TreeSet();

        set.add(new User("Tom",12));
        set.add(new User("Rose",23));
        set.add(new User("Jerry",2));
        set.add(new User("Eric",18));
        set.add(new User("Tommy",44));
        set.add(new User("Jim",23));
        set.add(new User("Maria",18));
        // set.add("Tom");

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println(set.contains(new User("Jack", 23))); // true
    }
}

案例2

自定义实体类：User

package com.suyv.set;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 13:54
*@Description: 实体类User
*/
public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    public User(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 "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    // 比如：先比较年龄从小到大排列，如果年龄相同，则继续比较姓名，从大到小
    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }

        if(o instanceof User){
            User u = (User)o;
            int value = this.age - u.age;
            if(value != 0){
                return value;
            }
            return -this.name.compareTo(u.name);
        }

        throw new RuntimeException("类型不匹配");
    }
}

TreeSet测试类

package com.suyv.set;

import java.util.Iterator;
import java.util.TreeSet;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 13:57
*@Description: TreeSet自然排序的使用
*/
public class TreeSetDemo02 {

    public static void main(String[] args) {
        TreeSet set = new TreeSet();

        set.add(new User("Tom",12));
        set.add(new User("Rose",23));
        set.add(new User("Jerry",2));
        set.add(new User("Eric",18));
        set.add(new User("Tommy",44));
        set.add(new User("Jim",23));
        set.add(new User("Maria",18));
        // set.add("Tom");

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println(set.contains(new User("Jack", 23))); // false
        
    }
}

4.2 TreeSet定制排序

Comparator 可以看成一个外部比较器，好处不用修改原代码直接实现

package com.suyv.set;

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-16 14:55
*@Description: TreeSet定制排序
*/
public class TreeSetDemo03 {
    
    @Test
    public void Test01(){
        Comparator comparator = new Comparator() {
            /*
             * 按照姓名从小到大排列，如果姓名相同，继续比较age，按照从大到小排列
             * */
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;

                    int value = u1.getName().compareTo(u2.getName());
                    if(value != 0){
                        return value;
                    }
                    return -(u1.getAge() - u2.getAge());
                }
                throw new RuntimeException("类型不匹配");
            }
        };

        TreeSet set = new TreeSet(comparator);

        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",43);
        User u3 = new User("Rose",13);
        User u4 = new User("Jack",23);
        User u5 = new User("Tony",33);
        User u6 = new User("Tom",33);

        set.add(u1);
        set.add(u2);
        set.add(u3);
        set.add(u4);
        set.add(u5);
        set.add(u6);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

Comparable<T> 内部比较器，需要修改原代码，不符合OCP原则

重写方法： public int compareTo(T t)

Comparator 可以看成一个外部比较器，好处不用修改原代码直接实现

重写方法： public int compare(Ojbect s1, Ojbect s2)

返回值类型：int 等于0 表示相等大于0表示升序小于0表示是降序