TreeSet

一：TreeSet的特点：

1.不重复，无索引，可排序

2.可排序：按照元素的默认规则（由小到大）排序

3.TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好

二：TreeSet对象排序练习题

存储整数并进行排序

import java.util.Iterator;
import java.util.TreeSet;
import java.util.function.Consumer;

public class treeset {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(1);
        ts.add(3);
        ts.add(5);
        ts.add(4);
        ts.add(2);
        System.out.println(ts);
        //迭代器
        Iterator<Integer> it = ts.iterator();
        while (it.hasNext()) {
            int i = it.next();
            System.out.println(i);
        }
        //增强for
        for (int t : ts) {
            System.out.println(t);
        }
        //lambda表达式
        ts.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
        //lambda表达式省略
        ts.forEach(i -> System.out.println(i));
    }
}

三：TreeSet集合默认的规则：

1.对于数值类型：Integer，Double，默认按照从小到大的顺序进行排序

2.对于字符，字符串类型：按照字符在ASCII码表中的数组升序进行排序

在字符串中会从左到右依次比较两个字符串中的同一个位置上的字符的大小，一旦确定哪个更大就会确定两者的先后顺序

例如：

1.字符串aaa比字符串ab小

2.字符串ab比字符串aba小

3.字符串aba比cd小

四：TreeSet对象排序练习题

需求：创建TreeSet集合，并添加3个学生对象

学生对象属性：

姓名，年龄

要求按照学生的年龄进行排序

同年龄按照姓名字母排列

同姓名，同年龄认为是同一个人

（本题中我们所要重点关注的是TreeSet的两种比较方式

方式一：默认排序/自然排序：javabean类实现Comparable接口指定的比较规则

Student：（只需要注意最后书写的比较方法的定义）

public class Student implements Comparable<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 +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //this：表示当前要添加的元素
        //o：表示已经存在于红黑树中的元素
        /*返回值：
        正数：添加的元素是大的，存在右边
        负数：添加的元素是小的，存在左边
        0：添加的元素已经存在，不添加进TreeSet中
         */
        return this.getAge() - o.getAge();
    }
}

treeset：

import java.util.TreeSet;

public class treeset {
    public static void main(String[] args) {
        Student s1 = new Student("A", 18);
        Student s2 = new Student("A", 18);
        Student s3 = new Student("D", 18);
        Student s4 = new Student("B", 19);
        Student s5 = new Student("C", 20);
        TreeSet<Student> ts = new TreeSet<>();
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        System.out.println(ts);
    }
}

方式二：比较器排序：创建TreeSet对象时，传递比较器Comparator指定规则

使用原则：默认使用第一种，如果第一种不能满足当前需求时考虑使用第二种

）

五：TreeSet对象排序练习题

需求：请自行选择比较器排序或自然排序两种方式

要求：存入四个字符串，“c”，“ab”，“df”，“qwer”

按照长度排序，如果长度相同则按照首字母排序

（未进行任何排序设置时）

import java.util.TreeSet;

public class treeet {
    public static void main(String[] args) {
        TreeSet<String> ts=new TreeSet<>();
        ts.add("c");
        ts.add("ab");
        ts.add("df");
        ts.add("qwer");
        //若未定义排序方式，则按照默认方式进行排序，即从左到右依次对每一个字符进行比较
        System.out.println(ts);
    }
}

（我们想要的排序方式）

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

public class treeet {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
            @Override
            //o1：现在要添加的元素
            //o2：已经存在于红黑树中的元素
            /*返回值：
            正数：添加的元素是大的，存在右边
            负数：添加的元素是小的，存在左边
            0：添加的元素已经存在，不添加进TreeSet中
            */
            public int compare(String o1, String o2) {
                int i = o1.length() - o2.length();
                //若i=0则代表o1与o2长度相同，如果是这种情况则调用默认的比较方式，但若不是这种情况则按照i的取值正负为准
                i = i == 0 ? o1.compareTo(o2) : i;
                return i;
            }
        });
        ts.add("c");
        ts.add("ab");
        ts.add("df");
        ts.add("qwer");
        //若未定义排序方式，则按照默认方式进行排序，即从左到右依次对每一个字符进行比较
        System.out.println(ts);
    }
}

有关能否改写成lambda表达式的一个注意点：

上方的接口是否是函数式接口，若是，则可以改写，反之则不能

（改写为lambda表达式的样子）

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

public class treeet {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>((o1, o2) -> {
            //o1：现在要添加的元素
            //o2：已经存在于红黑树中的元素
            /*返回值：
            正数：添加的元素是大的，存在右边
            负数：添加的元素是小的，存在左边
            0：添加的元素已经存在，不添加进TreeSet中
            */
                    int i = o1.length() - o2.length();
            //若i=0则代表o1与o2长度相同，如果是这种情况则调用默认的比较方式，但若不是这种情况则按照i的取值正负为准
            i = i == 0 ? o1.compareTo(o2) : i;
            return i;
        });
        ts.add("c");
        ts.add("ab");
        ts.add("df");
        ts.add("qwer");
        //若未定义排序方式，则按照默认方式进行排序，即从左到右依次对每一个字符进行比较
        System.out.println(ts);
    }
}

六：TreeSet对象排序练习题

需求：创建5个学生对象

属性：姓名，年龄，语文成绩，数学成绩，英语成绩

排序规则：

按照总分从高到低输出到控制台

如果总分一样，按照语文成绩排

如果语文一样，按照数学成绩排

如果数学成绩一样，按照英语成绩排

如果英语成绩一样，按照年龄排

如果年龄一样，按照姓名的字母顺序排

如果都一样，认为是同一个学生，不存

Student：

public class Student {
    private String name;
    private int age;
    private int ChineseScore;
    private int MathScore;
    private int EnglishScore;
    public Student(){

    }

    public Student(String name, int age, int chineseScore, int mathScore, int englishScore) {
        this.name = name;
        this.age = age;
        ChineseScore = chineseScore;
        MathScore = mathScore;
        EnglishScore = englishScore;
    }

    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 int getChineseScore() {
        return ChineseScore;
    }

    public void setChineseScore(int chineseScore) {
        ChineseScore = chineseScore;
    }

    public int getMathScore() {
        return MathScore;
    }

    public void setMathScore(int mathScore) {
        MathScore = mathScore;
    }

    public int getEnglishScore() {
        return EnglishScore;
    }

    public void setEnglishScore(int englishScore) {
        EnglishScore = englishScore;
    }

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

treeset：

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

public class treeset {
    public static void main(String[] args) {
        Student s1=new Student("A",18,60,60,60);
        Student s2=new Student("B",19,70,70,70);
        Student s3=new Student("C",20,80,80,80);
        Student s4=new Student("D",21,90,90,90);
        Student s5=new Student("E",22,100,100,100);
        Student s6=new Student("E",22,100,100,100);
        TreeSet<Student> ts=new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int AllScore= o1.getChineseScore()+o1.getMathScore()+o1.getEnglishScore()- o2.getChineseScore()-o2.getMathScore()- o2.getEnglishScore();
                int ChineseScore = o1.getChineseScore() - o2.getChineseScore();
                int MathScore=o1.getMathScore()-o2.getMathScore();
                int EnglishScore=o1.getEnglishScore()-o2.getEnglishScore();
                int age=o1.getAge()-o2.getAge();
                if(AllScore==0) {
                    return ChineseScore;
                }
                if(AllScore<0 || AllScore>0){
                    return AllScore;
                }
                if (ChineseScore==0){
                    return MathScore;
                }
                if(ChineseScore<0 ||ChineseScore>0){
                    return ChineseScore;
                }
                if (MathScore==0){
                    return EnglishScore;
                }
                if(MathScore<0 ||MathScore>0){
                    return MathScore;
                }
                if (EnglishScore==0){
                    return age;
                }
                if(EnglishScore<0 ||EnglishScore>0){
                    return EnglishScore;
                }
                if (age==0){
                    compare(o1,o2);
                }
                if(age<0 ||age>0){
                    return age;
                }
                return 0;
            }
        });
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        System.out.println(ts);
    }
}

七：小结

（1）：TreeSet集合的特点是怎么样的？

1.可排序，不重复，无索引

2.底层基于红黑树实现排序，增删改查性能较好

（2）.TreeSet集合自定义排序规则有几种方式

方式一：javabean类实现Comparable接口，指定比较规则

方式二：创建集合时，自定义Comparator比较器对象，指定比较规则

（3）：方法返回值的特点

1.正数：添加的元素是大的，存在右边

2.负数：添加的元素是小的，存在左边

3.0：添加的元素已经存在，不添加进TreeSet中