Java --> Set系列集合

 

 

• HashSet、LinkedHashSet

    public static void main(String[] args) {
        //Set系列集合：HashSet、LinkedHashSet、TreeSet
        //多态写法
        //Set<String> sets = new HashSet<>(); //HashSet：无序、不重复、无索引
        Set<String> sets = new LinkedHashSet<>(); // LinkedHashSet:有序、不重复、无索引
        sets.add("Java");
        sets.add("C语言");
        sets.add("数据结构");
        sets.add("Java");
        sets.add("HTML");
        sets.add("CSS");
        System.out.println(sets);
    }

HashSet示例运行结果：

LinkedHashSet示例运行结果：

•  相同对象的哈希值是一样的，不同对象的哈希值是不同的（对象的哈希值一旦确定，便不会改变，即与运行次数无关）：

 

 

  

 

 

 可以看到，两次运行的结果是一样的。

•  HashSet1.7版本原理解析：（数组+链表）

 

 

•  JDK1.8之后开始HashSet原理解析：数组 + 链表 + 红黑树 ，众所周知，当JDK1.8之前，如上边的1.7而言，当多个元素的哈希值相等时，改地址的元素就会变成链表，而我们知道，一旦链表的长度过长，便会使得元素的删除和查询性能大大降低。当链表的长度大于8的时候，便会自动转换为红黑树。有关红黑树的具体知识大家可参考这篇文章，个人感觉算是介绍的非常详细的一篇了：
• https://www.zhihu.com/question/312327402/answer/1263993419

 

 

•  案例：Set集合去重复
• 需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历改集合，要求：学生对象的成员变量值相同，我们就认为时同一个对象。

实现步骤分析：

1. 定义学生类，创建HashSet集合对象，创建学生对象；
2. 把学生添加到集合中；
3. 重点：在学生列中重写两个方法 -- hashCode()和equals(),自动生成即可;
   
4. 遍历集合（增强for）。

学生类：

public class Student {
    private String name;
    private int age;
    private char sex;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

    @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 && sex == student.sex && Objects.equals(name, student.name);
    }

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

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

public static void main(String[] args) {
        //Set集合去重复原因：先判断哈希值，在判断equals
        Set<Student> stus = new HashSet<>();
        Student s1 = new Student("Jack",21,'男');
        Student s2 = new Student("Jack",21,'男');
        Student s3 = new Student("Rose",20,'女');

        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());

        stus.add(s1);
        stus.add(s2);
        stus.add(s3);

        System.out.println(stus);
    }

示例运行结果：

 

 

 通过重写对象的hashCode和equals方法，可以实现Set集合中2个内容相同的对象就是重复的。

 

 

 示例运行结果：

 

 

 底层原理：基于哈希表，每个元素额外多了一个双链表的机制记录存储的顺序

 

 

•  实现类：TreeSet
• 不重复、无索引、可排序
• 案例：TreeSet集合的比较规则（数值型、字符串型、以及自定义类型）：

Cat类：

public class Cat implements Comparable<Cat>{ //实现Comparable接口，重写compareTo方法可实现自定义比较规则
    private String name;
    private String color;
    private int age;
    private double weight;

    //类自定义比较规则
    @Override
    public int compareTo(Cat o) {
        return this.age - o.age; //年龄升序(反之年龄降序)
        //return (this.age - o.age >= 0) ? 1 : -1; //保留相同对象
        //return Double.compare(this.weight,o.weight); //体重升序(反之体重降序)
        //return (this.weight - o.weight >= 0) ? 1 : -1; //保留相同对象
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", age=" + age +
                ", weight=" + weight +
                '}';
    }

    public Cat() {
    }

    public Cat(String name, String color, int age, double weight) {
        this.name = name;
        this.color = color;
        this.age = age;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}

public static void main(String[] args) {
        System.out.println("-----------数值型-------------");
        Set<Integer> sets = new TreeSet<>(); //不重复、无索引、可排序
        sets.add(18);
        sets.add(19);
        sets.add(21);
        sets.add(5);
        System.out.println(sets);

        System.out.println("-------------字符串型(ASCII)--------------");
        Set<String> sets2 = new TreeSet<>();
        sets2.add("Java");
        sets2.add("HTML");
        sets2.add("CSS");
        sets2.add("MySQL");
        sets2.add("HTML");
        sets2.add("java");
        sets2.add("棒");
        System.out.println(sets2);

        System.out.println("------------自定义比较规则-------------");
        Set<Cat> cats = new TreeSet<>();
        cats.add(new Cat("大橘猫","橘色",2,2.5));
        cats.add(new Cat("狸花猫","狸色",1,1.5));
        cats.add(new Cat("小黑","黑色",3,3.5));
        cats.add(new Cat("小黑","黑色",3,3.5));
        System.out.println(cats);
    }

示例运行结果：

 

 

 

 

 

 以上便是在类中实现Comparable接口，在类中重写comparaTo方法的方式实现了TreeSet集合的自定义排序。

• 方式二：TreeSet集合自带比较器对象进行规则定制

 

 

 

 

 可以看到：集合内部的比较器会优先使用。还可以使用Lambda表达式简化函数式接口的匿名内部类：

 

 

 

---

对此，我们对Collection体系的集合做一个简答的总结：

1. 如果希望元素可以重复，又有索引，索引查询快时可用ArrayList集合，因为它时基于数组的。（用的最多）；
2. 如果希望元素可以重复，又有索引，增删首位操作快则可以使用LinkedList集合，基于链表；
3. 如果希望增删改查相对都较快，但是元素不重复、无序、无索引，可以使用HashSet,基于哈希表
4. 如果希望增删改查都快，但是元素不重复、有序、无索引，可以使用LinkedHashSet，基于哈希表和双链表；
5. 如果希望对对象进行排序，可以使用TreeSet集合，基于红黑树。后续也可以使用List集合进行排序。