一.TreeSet的特点：
二.TreeSet对象排序练习题：
需求：利用TreeSet存储整数并进行排序
package com.itheima.a06mySet;
import java.util.TreeSet;
public class A05_TreeSetDemo1 {
public static void main(String[] args) {
//1.创建TreeSet集合对象
TreeSet<Integer> ts=new TreeSet<>();//注：泛型如果是基本数据类型的话要用包装类
//2.添加元素
ts.add(4);
ts.add(5);
ts.add(1);
ts.add(3);
ts.add(2);
//3.打印集合
System.out.println(ts);
/* 运行结果为[1, 2, 3, 4, 5]
已经排好序了，默认排序规则为从小到大
*/
}
}对刚才的集合进行遍历：
-
迭代器：
package com.itheima.a06mySet; import java.util.Iterator; import java.util.TreeSet; public class A05_TreeSetDemo1 { public static void main(String[] args) { //1.创建TreeSet集合对象 TreeSet<Integer> ts=new TreeSet<>();//注：泛型如果是基本数据类型的话要用包装类 //2.添加元素 ts.add(4); ts.add(5); ts.add(1); ts.add(3); ts.add(2); //3.遍历集合 Iterator<Integer> it=ts.iterator(); while (it.hasNext()){ Integer i = it.next();//这里i也可以用int型，因为JDK5有自动装箱和自动拆箱的功能 System.out.print(i+","); } /* 遍历结果为 1,2,3,4,5, */ } } -
增强for：
package com.itheima.a06mySet; import java.util.TreeSet; public class A05_TreeSetDemo1 { public static void main(String[] args) { //1.创建TreeSet集合对象 TreeSet<Integer> ts=new TreeSet<>();//注：泛型如果是基本数据类型的话要用包装类 //2.添加元素 ts.add(4); ts.add(5); ts.add(1); ts.add(3); ts.add(2); //3.遍历集合 for (Integer t : ts) { System.out.print(t+","); } /* 遍历结果为 1,2,3,4,5, */ } } -
Lambda表达式：
未使用Lambda表达式前：
package com.itheima.a06mySet;
import java.util.TreeSet;
import java.util.function.Consumer;
public class A05_TreeSetDemo1 {
public static void main(String[] args) {
//1.创建TreeSet集合对象
TreeSet<Integer> ts=new TreeSet<>();//注：泛型如果是基本数据类型的话要用包装类
//2.添加元素
ts.add(4);
ts.add(5);
ts.add(1);
ts.add(3);
ts.add(2);
//3.遍历集合
ts.forEach(new Consumer<Integer>() { //forEach是一个方法，底层用了增强for遍历集合
@Override //重写了Consumer接口的抽象方法
public void accept(Integer i) {
System.out.print(i+",");
}
});
/* 遍历结果为
1,2,3,4,5,
*/
}
}使用Lambda表达式后：
package com.itheima.a06mySet;
import java.util.TreeSet;
public class A05_TreeSetDemo1 {
public static void main(String[] args) {
//1.创建TreeSet集合对象
TreeSet<Integer> ts=new TreeSet<>();//注：泛型如果是基本数据类型的话要用包装类
//2.添加元素
ts.add(4);
ts.add(5);
ts.add(1);
ts.add(3);
ts.add(2);
//3.遍历集合
ts.forEach(i ->
System.out.print(i+",")
);
/* 遍历结果为
1,2,3,4,5,
*/
}
}
三.TreeSet集合默认的规则：
1.非自定义数据类型排序：
例如字符串排序："aaa"，"aba"，"qwer"，"ab"，"cd"
排序后为："aaa"，"ab"，"aba"，"cd"，"qwer"（默认是升序排序）
从第一个开始比，只要发现大的就停止比较，对于"ab"和"aba"，"ab"前两个和"aba"一样，"ab"在第三个
比"aba"少一个字母，默认比"aba"小。
2.自定义类型排序：
如：需求：创建TreeSet集合，并添加3个学生对象
学生对象属性：姓名，年龄。
要求按照学生的年龄进行排序
同年龄按照姓名字母排列（暂不考虑中文）
同姓名，同年龄认为是同一个人
错解：
Student类：
package com.itheima.a06mySet;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
测试类：
package com.itheima.a06mySet;
import java.util.TreeSet;
public class A05_TreeSetDemo2 {
public static void main(String[] args) {
//1.创建3个学生对象
Student s1=new Student("zhangsan",23);
Student s2=new Student("lisi",24);
Student s3=new Student("wangwu",25);
//2.创建集合对象
TreeSet<Student> ts=new TreeSet<>();
//3.添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
//4.打印集合
System.out.println(ts);
}
}
打印结果会报错，因为s1，s2和s3都是自定义的类型，此时没有指明比较规则，添加元素的时候也就无法进行比较再添加，在添加元素时就已经出错了。
正解：需要指明比较规则。
四.TreeSet的两种比较方式：（如果两种比较方式都存在，则以方式二为准）
方式一：默认排序/自然排序：Javabean类实现Comparable接口指定比较规则
接刚才的例子：需要Student类实现Comparable接口，重写里面的抽象方法，再指定比较规则
Student类：
package com.itheima.a06mySet;
public class Student implements Comparable<Student>{ //此时已经明确比较排序的就是Student型
// 用了接口Comparable，本例中要写比较规则，所以重写方法
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
@Override
public int compareTo(Student o) {
//指定排序规则
/* 只看年龄
要按照年龄的升序进行排序
*/
int result=this.getAge() - o.getAge();
return result;
}
/* 不需要重写hashCode和equals方法
因为hashCode和equals方法是和哈希表有关的
而TreeSet底层是红黑树
*/
}
注：在这种重写后的方法下才有相同的不存的效果，因为底层是红黑树。自己写的一般没有相同的不存的效果。
测试类：
package com.itheima.a06mySet;
import java.util.TreeSet;
public class A05_TreeSetDemo2 {
public static void main(String[] args) {
//1.创建3个学生对象
Student s1=new Student("zhangsan",23);
Student s2=new Student("lisi",24);
Student s3=new Student("wangwu",25);
//2.创建集合对象
TreeSet<Student> ts=new TreeSet<>();
//3.添加元素
ts.add(s3);
ts.add(s2);
ts.add(s1);
//4.打印集合
System.out.println(ts);
/* 运行结果为
[Student{name = zhangsan, age = 23}, Student{name = lisi, age = 24},
Student{name = wangwu, age = 25}]
已经指明了比较规则，此时可正常运行
*/
}
}解释Student类里的compareTo方法：
先添加25（s3），要变黑，因为是根节点。再添加24（s2），此时25（s3）是o，24（s2）是this：
添加后，刚好符合红黑树规则：
再添加23（s1），此时23（s1）是this。注：先和25（s3）比较，因为25（s3）是根节点（添加元素时一定是先和根节点进行比较），此时25（s3）是o。
经过比较后23（s1）存左边，但左边已经有24（s2），因此继续调用compareTo方法进行比较添加。
此时24（s2）是o，23（s1）是this-->经过比较添加后为：
但此时不符合红黑树规则，需要进行一系列改正操作。s1为非根节点，s1的父为红色，叔叔为Nil即黑色，且s1是父的左孩子，因此进行3的操作，注：祖父为s3，右旋时不考虑叶子节点，结果为：
结果中叶子节点省略了
此时根节点变为24（s2）,再添加元素时就是先和根节点24（s2）比较了
代码解释：
Student类：
package com.itheima.a06mySet;
public class Student implements Comparable<Student>{ //此时已经明确比较排序的就是Student型
// 用了接口Comparable，本例中要写比较规则，所以重写方法
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
@Override
//this:表示当前要添加的元素
//o:表示已经在红黑树中存在的元素
/* 返回值：
负数：表示当前要添加的元素是小的，就要存左边
正数：表示当前要添加的元素是大的，就要存右边
0：表示当前要添加的元素已经存在，此时要舍弃（因为TreeSet集合不重复）
*/
public int compareTo(Student o) {
System.out.println("--------------------------------------");
System.out.println("this："+this);
System.out.println("o："+o);
//指定排序规则
/* 只看年龄
要按照年龄的升序进行排序
*/
int result=this.getAge() - o.getAge();
return result;
}
/* 不需要重写hashCode和equals方法
因为hashCode和equals方法是和哈希表有关的
而TreeSet底层是红黑树
*/
}测试类：
package com.itheima.a06mySet;
import java.util.TreeSet;
public class A05_TreeSetDemo2 {
public static void main(String[] args) {
//1.创建3个学生对象
Student s1=new Student("zhangsan",23);
Student s2=new Student("lisi",24);
Student s3=new Student("wangwu",25);
//2.创建集合对象
TreeSet<Student> ts=new TreeSet<>();
//3.添加元素
ts.add(s3);
ts.add(s2);
ts.add(s1);
//4.打印集合
System.out.println(ts);
}
}运行结果为：
一开始先添加的25（s3）,但一开始没有节点，因此第一次25（s3）自己和自己比较
25（s3）为根节点，因为第一次添加
方式二：比较器排序：创建TreeSet对象时，传递比较器Comparator指定规则
(使用原则：默认使用第一种比较方式，如果第一种比较方式不能满足当前需求，就使用第二种比较方式。如字符串里的compareTo方法在idea底层是按照字母顺序进行排序的，如果此时想用别的方式排序，就需要进行大量操作，但太麻烦，因此就需要用第二种排序方式指定比较排序规则；再比如Integer型默认从小到大排，要想从大到小排，最好选第二种排序方式)
Comparator<T>属于函数式接口，可以改用Lambda表达式
例如：
需求：请自行选择比较器排序和自然排序两种方式；
要求：存入四个字符串，"c"，"ab"，"df"，"qwer"
按照长度排序，如果一样长则按照首字母排序
分析：字符串比较方式idea已经写好，虽然可以修改源码来定义自己的排序方式，但太麻烦，因此用比较器排序
package com.itheima.a06mySet;
import java.util.Comparator;
import java.util.TreeSet;
public class A06_TreeSetDemo3 {
public static void main(String[] args) {
//1.创建集合
//o1:表示当前要添加的元素
//o2:表示已经在红黑树中存在的元素
//返回值规则：小的存左边，大的存右边，一样的不存
//先定好规则再添加元素
TreeSet<String> ts=new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//a.按照长度排序
int i = o1.length() - o2.length();
//b.如果一样长则按照首字母排序(即默认排序方式-->o1.compareTo(o2)),不一样长以长度为准即i
i = i==0?o1.compareTo(o2):i;
return i;
}
});
//2.添加元素
ts.add("c");
ts.add("ab");
ts.add("df");
ts.add("qwer");
//3.打印集合
System.out.println(ts);//运行结果为[c, ab, df, qwer]
}
}注：compare是重写的方法的名字，compareTo是比较字符串用的方法。
改用Lambda表达式：
package com.itheima.a06mySet;
import java.util.TreeSet;
public class A06_TreeSetDemo3 {
public static void main(String[] args) {
//1.创建集合
//o1:表示当前要添加的元素
//o2:表示已经在红黑树中存在的元素
//返回值规则：小的存左边，大的存右边，一样的不存
TreeSet<String> ts=new TreeSet<>((o1,o2) -> {
//a.按照长度排序
int i = o1.length() - o2.length();
//b.如果一样长则按照首字母排序(即默认排序方式-->o1.compareTo(o2)),不一样长以长度为准即i
i = i==0?o1.compareTo(o2):i;
return i;
});
//2.添加元素
ts.add("c");
ts.add("ab");
ts.add("df");
ts.add("qwer");
//3.打印集合
System.out.println(ts);//运行结果为[c, ab, df, qwer]
}
}五.TreeSet对象排序练习题：
题目如下：
解：
Student类：
package a32mySet;
public class Student implements Comparable<Student>{
//姓名
private String name;
//年龄
private int age;
//语文成绩
private int chinese;
//数学成绩
private int math;
//英语成绩
private int english;
public Student() {
}
public Student(String name, int age, int chinese, int math, int english) {
this.name = name;
this.age = age;
this.chinese = chinese;
this.math = math;
this.english = english;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
/**
* 获取
* @return chinese
*/
public int getChinese() {
return chinese;
}
/**
* 设置
* @param chinese
*/
public void setChinese(int chinese) {
this.chinese = chinese;
}
/**
* 获取
* @return math
*/
public int getMath() {
return math;
}
/**
* 设置
* @param math
*/
public void setMath(int math) {
this.math = math;
}
/**
* 获取
* @return english
*/
public int getEnglish() {
return english;
}
/**
* 设置
* @param english
*/
public void setEnglish(int english) {
this.english = english;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + ", chinese = " + chinese +
", math = " + math + ", english = " + english + "}";
}
@Override
public int compareTo(Student o) {
//求已有的人(this)的总分和要添加的人(o)的总分
int sum1=this.getChinese()+this.getMath()+this.getEnglish();
int sum2=o.getChinese()+o.getMath()+o.getEnglish();
//总分做差
int i=sum1-sum2;
//1.先比总分，总分一样，比语文,总分不一样正常来
i = i==0?this.getChinese()-o.getChinese():i;
//2.语文一样比数学
i = i==0?this.getMath()-o.getMath():i;
//3.数学一样比英语(可省略，因为前面已经证明总分，数学和语文都一样了，那么英语必然一样，且一共就语数英三科)
i = i==0?this.getEnglish()-o.getEnglish():i;
//4.英语一样比年龄
i = i==0?this.getAge()-o.getAge():i;
//5.年龄一样比姓名
i = i==0?this.getName().compareTo(o.getName()):i;
/*当比到姓名时，说明除了姓名外其他属性都一样，如果姓名也一样，则代表属性都一样，且用到了
方法compareTo，它的底层是红黑树，就不会添加，刚好做到了去重
(String型属于idea已经写好的,他的compareTo方法可以直接用)
*/
return i;
}
}测试类：
package a32mySet;
import java.util.TreeSet;
public class A07_TreeSetDemo4 {
public static void main(String[] args) {
//1.创建学生对象
Student s1=new Student("zhangsan",23,90,99,50);
Student s2=new Student("lisi",24,90,98,50);
Student s3=new Student("wangwu",25,95,100,30);
Student s4=new Student("zhaoliu",26,60,99,70);
Student s5=new Student("qianqi",26,70,80,70);
//2.创建集合
TreeSet<Student> ts=new TreeSet<>();
//3.添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
//4.打印集合
for (Student t : ts) {
System.out.println(t);
}
}
}运行结果：
六.总结：
七.单列集合使用场景：
