Set集合的子集合TreeSet集合

TreeSet集合也是Set集合的子集合，TreeSet集合间接实现了Set集合，相对于HashSet集合，TreeSet集合更多的自己独特的方法。本篇文章将介绍TreeSet集合的相关内容。

一、TreeSet集合概述
（1）TreeSet集合特点
① 元素有序，这里的有序是不指元素的存储和取出的顺序，而是一种特殊规则进行的排序，具体的排序方式取决于构造方法。
TreeSet():根据其元素的自然排序进行排序
TreeSet(Comparator com)；根据指定的比较器进行排序
②也是没有索引，不能使用普通for循环遍历
③ 也没有重复的元素
（2）练习，存储整数并遍历

import java.util.TreeSet;
/*
* TreeSet集合，
* 元素有序，这里的有序是不指元素的存储和取出的顺序，而是一种特殊规则进行的排序，具体的排序方式取决于构造方法。
* TreeSet():根据其元素的自然排序进行排序
* TreeSet(Comparator com)；根据指定的比较器进行排序
* 也是没有索引，不能使用普通for循环遍历
*  也没有重复的元素
* */
public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Integer> integers = new TreeSet<Integer>();
        integers.add(4);
        integers.add(2);
        integers.add(1);
        integers.add(3);
        for (Integer integer:integers
             ) {
            System.out.println(integer);
        }

    }
}

代码运行之后的结果是1 2 3 4 ，这是一种默认的构造方法中的自然数排序。

**二、自然排序Comparable的使用 **

这里要注意的是需要学生类实现 Comparable接口，重写 ComparTo()，在String和Integer中都有关于这个方法的重写，已实现按照自然数、英文字母排序’

import java.util.TreeSet;

/*
* 练习TreeSet
* 存储学生对象并遍历，创建集合使用无参构造方法
* 要求：按照年龄从小到大排序，年龄相同时，按照名字的首字母顺序排序
* */
public class Demo3 {
    public static void main(String[] args) {
        TreeSet<Student> students = new TreeSet<Student>();
        Student s1 = new Student("Bob",12);
        Student s2 = new Student("Tom",13);
        Student s3 = new Student("Jim",12);
        Student s4 = new Student("Mark",14);
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        for (Student s:students
             ) {
            System.out.println(s);
        }
/*
* 输出
* 学生{姓名='Bob', 年龄=12}
学生{姓名='Jim', 年龄=12}
学生{姓名='Tom', 年龄=13}
学生{姓名='Mark', 年龄=14}
* */
    }
}

public class Student implements Comparable<Student>{
    String name;
    int age;

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

    public Student() {}

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }*/

    @Override
    public String toString() {
        return "学生{" +
                "姓名='" + name + '\'' +
                ", 年龄=" + age +
                '}';
    }

    @Override
    public int compareTo(Student s) {
        //return 0;TreeSet集合只能存储并输出第一个元素
        //return 1；TreeSet集合中的元素正序存储
        //return -1;TreeSet集合中的元素逆序存储
        //age从小到大
        int num = this.age - s.age;//和上一个元素进行比较
        if(num==0){
            if(this.name.equals(s.name)){
                return 0;//重复元素，不存储
            }else {//年龄相同，姓名不同
                return this.name.compareTo(s.name);//String字符串有对字符从小到大的的自然排序方法的重写，直接盗用即可
            }
        }return num;
        /*
        * 精简写法
        * int num1 = num==0?this.name.compareTo(s.name):num;
        * return num1;
        * */
    }
}

三、比较器排序Comparator的使用

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

/*
*
* 练习TreeSet  Comparator比较器排序
* 存储学生对象并遍历，创建集合使用无参构造方法
* 要求：按照年龄从小到大排序，年龄相同时，按照名字的首字母顺序排序
*
* */
public class Demo4 {
    public static void main(String[] args) {
        TreeSet<Student> students = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
               // return 0;
                int num = s1.getAge()-s2.getAge();//调用Student的get方法来编写规则
                int num1 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num1;
            }

        });
        Student s1 = new Student("Bob",12);
        Student s2 = new Student("Tom",13);
        Student s3 = new Student("Jim",12);
        Student s4 = new Student("Mark",14);
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        for (Student s:students
                ) {
            System.out.println(s);
        }
    }
}
/*
* 输出
* 学生{姓名='Bob', 年龄=12}
学生{姓名='Jim', 年龄=12}
学生{姓名='Tom', 年龄=13}
学生{姓名='Mark', 年龄=14}
* */

结论
① 使用TreeSet集合存储自定义对象时，带参构造方法使用的是比较器排序对元素进行排序的
② 比较器排序时，就是让集合构造方法接收Comparator的实现类对象，重写Compare（T 01.T 02）方法
③ 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写。