JavaSE——集合（三）Set（HashSet，LinkedHashSet，TreeSet）

哈希值

• 概念
  哈希值是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存储的物理地址）
• 使用
  Object类就提供了求哈希值的方法

public native int hashCode();

演示

package com.westmo1.demo4;
public class MyDemo2 {
    public static void main(String[] args) {
        MyDemo2 myDemo2 = new MyDemo2();
        System.out.println(myDemo2.hashCode());
        MyDemo2 myDemo21 = new MyDemo2();
        System.out.println(myDemo21.hashCode());
    }
}

• String类演示

package com.westmo1.demo4;
public class MyDemo2 {
    public static void main(String[] args) {
        String abc = new String("abc");
        String abc1 = new String("abc");
        System.out.println(abc.hashCode());//96354
        System.out.println(abc1.hashCode());//96354
        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
    }
}

1.HashSet

• 概述

（1）底层数据结构是哈希表，元素唯一且无序。
①jdk1.8以前：哈希表=数组+链表
②jdk1.8以后：哈希表=数组+链表+红黑树
（2）数据结构：数组结构：对元素进行了分组（相同哈希值的元素在一组），链表/红黑树结构：将相同哈希值的元素连接到一起

（3） 哈希冲突：两个元素不同，但是哈希值相同，就会发生哈希冲突

• 案例演示

package com.westmo1.demo1;
import java.util.HashSet;
public class MyDemo1 {
    public static void main(String[] args) {
        HashSet<String> strings = new HashSet<>();
        strings.add("123");
        strings.add("qewq");
        for (String string : strings) {
            System.out.println(string);
        }
    }
}

• HashSet保证元素唯一性（以hashset.add(“重地”)为例）

首先add方法会调用hashCode方法来获取字符串"重地"的哈希码值，它的哈希码值是1179395，在集合中找有没有1179395这个哈希码值的元素：
（1）如果有(哈希冲突)："重地"就会调用equals方法和哈希码值相同的元素进行比较：
①返回为true:则两个元素相同，"重地"就不存储到集合中。
②返回为false：则存储到集合中（以链表/红黑数的形式链接到哈希码值相同的元素的后面）。
（2）如果没有：就将"重地"存储到集合中。
所以：HashSet保证元素唯一性是靠重写hashCode()和equals()方法来保证的，如果不重写则无法保证。

• HashSet存储自定义对象保证元素唯一性

package com.westmo1.demo1;
import java.util.HashSet;
public class MyDemo2 {
    public static void main(String[] args) {
        Student student = new Student("张三", 13);
        Student student1 = new Student("张三", 13);
        Student student2 = new Student("李四", 15);
        Student student3 = new Student("李四", 15);
        Student student4 = new Student("王五", 18);
        HashSet<Student> students = new HashSet<>();
        students.add(student);
        students.add(student1);
        students.add(student2);
        students.add(student3);
        students.add(student4);
        for (Student student5 : students) {
            System.out.println(student5);
        }
    }
}
package com.westmo1.demo1;
import java.util.Objects;
public class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

• HashSet存储自定义对象保证元素唯一性图解

2.LinkedHashSet

• 概述

底层数据结构是由链表和哈希表实现的，链表保证有序，哈希表保证元素唯一。

• 案例演示

package com.westmo1.demo1;
import java.util.LinkedHashSet;
public class MyDemo3 {
    public static void main(String[] args) {
        LinkedHashSet<Integer> integers = new LinkedHashSet<>();
        integers.add(300);
        integers.add(100);
        integers.add(400);
        integers.add(100);
        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }
}

3.TreeSet

概述

TreeSet集合特点：元素唯一，并且可以对元素进行排序，
排序有两种方式：自然排序和使用比较器排序。

使用TreeSet集合进行元素的自然排序

• 注意事项：采用空参构造，要求元素必须实现Comparable接口

• 案例演示

package com.westmo1.demo1;
import java.util.TreeSet;
public class MyDemo4 {
    public static void main(String[] args) {
        TreeSet<Integer> integers = new TreeSet<>();
        /*存储下列元素:  20 , 18 , 23 , 22 , 17 , 24, 19 , 18 , 24*/
        integers.add(20);
        integers.add(18);
        integers.add(23);
        integers.add(22);
        integers.add(17);
        integers.add(24);
        integers.add(19);
        integers.add(18);
        integers.add(24);
        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }
}

• 自然排序的原理

利用二叉树的数据结构，现存入一个树根，分两个叉，存储元素时，和树根比较，小的放在左边，大的放在右边，如果相等就不存储。

• TreeSet存储自定义对象并遍历1

//按照年龄来排序，注意特殊情况
package com.westmo1.demo1;
public class Student1 implements Comparable<Student1>{
    private String name;
    private int age;

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Student1 o) {
        int num=this.age-o.age;
        int num1=this.name.compareTo(o.name);
        if (num==0) {
            num=num1;
        }
        return num;
    }
}
//从例中可以看出，TreeSet集合自然排序需要实现Compraable接口和重写compareTo方法。
package com.westmo1.demo1;
import java.util.TreeSet;
public class MyDemo5 {
    public static void main(String[] args) {
        Student1 student = new Student1("张三", 13);
        Student1 student1 = new Student1("小花", 10);
        Student1 student2 = new Student1("李四", 19);
        Student1 student3 = new Student1("小明", 17);
        Student1 student4 = new Student1("王五", 13);
        TreeSet<Student1> student1s = new TreeSet<>();
        student1s.add(student);
        student1s.add(student1);
        student1s.add(student2);
        student1s.add(student3);
        student1s.add(student4);
        for (Student1 student11 : student1s) {
            System.out.println(student11);
        }
    }
}

• TreeSet存储自定义对象并遍历2

//按照姓名的长度排序，注意名字长度相同时，年龄相同时的情况。
package com.westmo1.demo1;
import java.util.TreeSet;
public class MyDemo6 {
    public static void main(String[] args) {
        Student2 student = new Student2("张三话", 13);
        Student2 student1 = new Student2("小花阿叔", 10);
        Student2 student2 = new Student2("李四", 19);
        Student2 student3 = new Student2("小明的股数打", 17);
        Student2 student4 = new Student2("王五", 19);
        TreeSet<Student2> student1s = new TreeSet<>();
        student1s.add(student);
        student1s.add(student1);
        student1s.add(student2);
        student1s.add(student3);
        student1s.add(student4);
        for (Student2 student11 : student1s) {
            System.out.println(student11);
        }
    }
}
package com.westmo1.demo1;
public class Student2 implements Comparable<Student2>{
    private String name;
    private int age;
    public Student2(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Student2 o) {
        int num2=this.name.length()-o.name.length();//先比较名字长度
        int num=this.name.compareTo(o.name);//再比较名字的内容
        int num1=this.age-o.age;//比较年龄
        if (num2==0) {
            num2=num;
        }
        if (num==0) {
            num2=num1;
        }
        return num2;
    }
}

使用TreeSet集合进行元素的自然排序(自定义比较器)

• 注意事项

自定义的比较器要实现Comparator接口，重写Compare方法。在创建TreeSet对象的时候，就传递一个比较器对象。

• 案例演示

package com.westmo1.demo1;
import java.util.Comparator;
import java.util.TreeSet;
public class MyDemo7 {
    public static void main(String[] args) {
        Student3 student1 = new Student3("小明",15);
        Student3 student2 = new Student3("小话",19);
        Student3 student3 = new Student3("小明挂个人",10);
        Student3 student4 = new Student3("李海华",15);
        NameComparable nameComparable = new NameComparable();//姓名比较器
        AgeComparable ageComparable = new AgeComparable();//年龄比较器
        TreeSet<Student3> student3s = new TreeSet<Student3>(nameComparable)；//传递姓名比较器对象，也可以用匿名内部类来实现
        student3s.add(student1);
        student3s.add(student2);
        student3s.add(student3);
        student3s.add(student4);
        for (Student3 student31 : student3s) {
            System.out.println(student31);
        }
    }
    static class Student3{
        private String name;
        private int age;
        public Student3(String name, int age) {
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Student3{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    //自定义年龄比较器对象
    static class AgeComparable implements Comparator {
        @Override
        public int compare(Object o1, Object o2) {
            Student3 o11 = (Student3) o1;
            Student3 o21 = (Student3) o2;
            int num=o11.age-o21.age;
            int num1=o11.name.compareTo(o21.name);
            if (num==0) {
                num=num1;
            }
            return num;
        }
    }
    //自定义姓名比较器对象
    static class NameComparable implements Comparator{
        @Override
        public int compare(Object o1, Object o2) {
            Student3 o11 = (Student3) o1;
            Student3 o21 = (Student3) o2;
            int num=o11.name.length()-o21.name.length();
            int num1=o11.name.compareTo(o21.name);
            int num2=o11.age-o21.age;
            if (num==0) {
                num=num1;
            }
            if (num1==0) {
                num=num2;
            }
            return num;
        }
    }
}

练习1（产生10个1-20之间的随机数要求随机数不能重复）

package com.westmo1.demo1;
import java.util.TreeSet;
public class MyDemo8 {
    public static void main(String[] args) {
        TreeSet<Integer> integers = new TreeSet<>();
        while(integers.size()<10) {
            int random = (int) (Math.random()*20+1);
            integers.add(random);
        }
        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }
}

练习2（键盘输入学生信息按照总分排序后输出，使用比较器进行）

package com.westmo1.demo1;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
public class MyDemo9 {
    public static void main(String[] args) {
    //使用匿名内部类来传参，不需要再创建一个类来实现Comparator接口这么麻烦。
        TreeSet<Student4> student4s = new TreeSet<Student4>(new Comparator<Student4>() {
            @Override
            public int compare(Student4 o1, Student4 o2) {
                int num=o1.getTotal()-o2.getTotal();
                int num1=num==0?o1.name.compareTo(o2.name):num;
                return -num1;
            }
        });
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("输入第" + i + "个学生的信息");
            String name = scanner.next();
            int math = scanner.nextInt();
            int chinese = scanner.nextInt();
            int english = scanner.nextInt();
            Student4 student4 = new Student4(name, math, chinese, english);
            student4s.add(student4);
        }
        for (Student4 student4 : student4s) {
            System.out.println(student4);
        }
    }
    static class Student4 {
        private String name;
        private int math;
        private int chinese;
        private int english;

        public Student4(String name, int math, int chinese, int english) {
            this.name = name;
            this.math = math;
            this.chinese = chinese;
            this.english = english;
        }
        @Override
        public String toString() {
            return "Student4{" +
                    "姓名='" + name +
                    ", 数学=" + math +
                    ", 语文=" + chinese +
                    ", 英语=" + english +",总分="+getTotal()+
                    '}';
        }
        public int getTotal(){
            return math+chinese+english;
        }
    }
}