TreeSet 集合

- 1. 概述
- 2. 方法
- 3. 遍历方式
- 4. 两种排序方式
- - 4.1 默认排序规则/自然排序
  - - 4.1.1 概述
    - 4.1.2 compareTo()方法
    - 4.1.3 代码示例1
    - 4.1.4 代码示例2
  - 4.2 比较器排序
  - - 4.2.1 概述
    - 4.2.2 compare()方法
    - 4.2.3 代码示例1
    - 4.2.4 代码示例2
  - 4.3 排序方式的对比
- 5. 注意事项

文章中的部分照片来源于哔站黑马程序员阿伟老师处，仅用学习，无商用，侵权联系删除！

其他集合类

祖父类 Collection

父类 Set

集合类的遍历方式

具体信息请查看 API 帮助文档

1. 概述

TreeSet是Java中的一个有序集合，它实现了Set接口。它使用红黑树数据结构来存储元素，并且保证元素按照升序排列。每个元素都必须是可比较的，或者在创建TreeSet时提供一个定制的Comparator来比较元素。

TreeSet集合：(底层是红黑树)

不重复，无索引，可排序
可排序：按照元素的默认规则（由小到大）进行排序
TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好

TreeSet的特点：

有序性：TreeSet中的元素按照升序排列，默认使用元素自然顺序进行比较，或者可以通过提供一个Comparator来指定定制的排序规则。
无重复性：TreeSet不允许存储重复的元素。如果尝试添加重复的元素，添加操作会被忽略。
高效性：由于采用了红黑树数据结构，TreeSet支持快速的插入、删除和查找操作，时间复杂度为O(logN)。

2. 方法

TreeSet集合是Set集合的子类，是Collection集合的孙子类，因此Set集合和Collection集合的方法都可以使用

Collection集合

Set集合

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

3. 遍历方式

【注意】TreeSet集合没有索引，因此只能用迭代器遍历、增强 for ，Lambda表达式遍历。

与共有的集合遍历方式一样

代码示例：

package text.text02;import java.util.Iterator;
import java.util.TreeSet;/*
TreeSet集合：(底层是红黑树)1.不重复，无索引，可排序2.可排序：按照元素的默认规则（由小到大）进行排序3.TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好需求：存储整数并进行排序*/
public class text40 {public static void main(String[] args) {//创建集合并添加数据TreeSet<Integer> ts = new TreeSet<>();ts.add(4);ts.add(7);ts.add(6);ts.add(3);ts.add(1);ts.add(5);ts.add(2);ts.add(8);ts.add(9);//打印集合System.out.println(ts);   //[1, 2, 3, 4, 5, 6, 7, 8, 9]//遍历集合Iterator<Integer> it = ts.iterator();while (it.hasNext()) {Integer i = it.next();System.out.print(i + "  ");          //1  2  3  4  5  6  7  8  9}}
}

输出结果

4. 两种排序方式

方法一：默认排序规则/自然排序

JavaBean类实现Comparable接口指定比较规则（重写里面的抽象方法，再比较）
方法二：比较器排序

创建TreeSet对象时候，自定义比较器Comparator对象，指定比较规则

4.1 默认排序规则/自然排序

4.1.1 概述

默认排序规则，也称为自然排序，是指针对某种数据类型的元素，按照它们的自身特性进行排序的规则。在Java中，如果一个类实现了Comparable接口，就意味着它具有自然顺序，并且可以使用默认排序规则。

在使用默认排序规则进行排序时，会根据元素的特定属性或者重写的compareTo()方法来进行比较。默认情况下，元素按照升序排列，也就是具有较小值的元素在集合中排在前面。

例如，对于整数类型，自然排序规则就是按照数值大小进行排序。而对于字符串类型，自然排序规则是按照字典顺序进行排序。

以下是一些实现了Comparable接口的示例类及其默认排序规则：

Integer类：按数值大小进行升序排序。
String类：按字典顺序进行排序。
LocalDate类：按日期进行升序排序。
自定义类：可以通过实现Comparable接口，并重写compareTo()方法来定义自己的默认排序规则。

注意，如果你想使用不同于默认排序规则的排序方式，可以通过提供一个定制的Comparator来实现定制排序。

默认排序示意图：
在这里插入图片描述

4.1.2 compareTo()方法

compareTo()方法是Comparable接口中定义的方法，用于比较当前对象与另一个对象的顺序。它的方法签名如下：

int compareTo(T obj)

其中，T表示要比较的对象的类型。compareTo()方法接受一个参数obj，表示要与当前对象进行比较的另一个对象，返回一个整数值表示它们的顺序关系。

this: 要添加的元素(当前对象）
obj：红黑树中已经存在的数据

compareTo()方法返回的整数值有以下三种情况：

当compare()方法返回一个负数时，表示第一个元素应排在前面；
当返回0时，表示两个元素相等；
当返回一个正数时，表示第一个元素应排在后面。

具体返回的值大小并不重要，只有它们的正负号和零的关系才有意义。返回的值为负，当前对象就应该排在obj之前；返回的值为正，当前对象就应该排在obj之后。

4.1.3 代码示例1

代码示例：

需求：创建TreeSet集合，并添加3个学生对象
学生对象属性：姓名、年龄
要求：按照学生的年龄进行排序，同年龄按照姓名字母排列（暂不考虑中文），同姓名、同年龄认为是同一个人

package text.text02;import java.util.Iterator;
import java.util.TreeSet;/* 方法一：默认排序规则/自然排序方法一：默认排序规则/自然排序JavaBean类实现Comparable接口指定比较规则（重写里面的抽象方法，再比较）
方法二：比较器排序创建TreeSet对象时候，传递比较器Comparator指定规则TreeSet对象排序练习题：
需求：创建TreeSet集合，并添加3个学生对象
学生对象属性：姓名、年龄
要求：按照学生的年龄进行排序，同年龄按照姓名字母排列（暂不考虑中文），同姓名、同年龄认为是同一个人*/
public class text41 {public static void main(String[] args) {//创建学生对象Student4 student1 = new Student4("zhangsan", 13);Student4 student2 = new Student4("llisi", 25);Student4 student3 = new Student4("wangwu", 12);Student4 student4 = new Student4("zhaoliu", 20);Student4 student5 = new Student4("liuqi", 11);//创建集合，并添加元素TreeSet<Student4> ts = new TreeSet<>();ts.add(student1);ts.add(student2);ts.add(student3);ts.add(student4);ts.add(student5);//遍历集合Iterator<Student4> it = ts.iterator();while (it.hasNext()) {Student4 student = it.next();System.out.println(student.getName() + "," + student.getAge());/*liuqi,11wangwu,12zhangsan,13zhaoliu,20llisi,25*/}}
}//重写CompareTo的实现了Comparable接口的学生类
class Student4 implements Comparable<Student4> {private String name;private int age;public Student4() {}public Student4(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 "Student4{name = " + name + ", age = " + age + "}";}//重写抽象方法CompareTo方法@Override//this:表示当前要添加的元素//o：表示已经在红黑树中的元素//返回值：//负数：表示当前要添加的数据是小的，存左边//正数：表示当前要添加的数据是大的，存右边//0：表示当前要添加的元素已经存在，舍弃public int compareTo(Student4 o) {System.out.println("---------------CompareTo方法-----------");System.out.println("this:" + this);System.out.println("o:" + o);System.out.println();//指定排序的规则//只看年龄：按照年龄的升序进行排列return this.getAge() - o.getAge();}}

输出结果

4.1.4 代码示例2

代码示例：
需求：创建5个学生对象
属性：姓名、年龄，语文成绩。数学成绩、英语成绩
要求：按照总分从高到低输出到控制台
如果总分一样，按照语文成绩排
如果语文一样，按照数学成绩排
如果数学一样，按照英语成绩排
如果英语一样，按照年龄排
如果都一样，认为是同一个学生，不存

package text.text02;
/*
TreeSet对象排序练习题：
需求：创建5个学生对象
属性：姓名、年龄，语文成绩。数学成绩、英语成绩
要求：按照总分从高到低输出到控制台如果总分一样，按照语文成绩排如果语文一样，按照数学成绩排如果数学一样，按照英语成绩排如果英语一样，按照年龄排如果都一样，认为是同一个学生，不存*///方法一：默认排序规则/自然排序
//    JavaBean类实现Comparable接口指定比较规则（重写里面的抽象方法，再比较）import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;public class text43 {public static void main(String[] args) {//创建5个学生对象text.text02.Student6 student1 = new text.text02.Student6("张三", 15, 99, 98, 90);text.text02.Student6 student2 = new text.text02.Student6("李四", 14, 79, 56, 36);text.text02.Student6 student3 = new text.text02.Student6("王五", 16, 95, 96, 85);text.text02.Student6 student4 = new text.text02.Student6("赵六", 19, 93, 68, 83);text.text02.Student6 student5 = new text.text02.Student6("刘备", 12, 75, 68, 73);//创建集合TreeSet<Student6> ts = new TreeSet<>();//添加学生对象ts.add(student1);ts.add(student2);ts.add(student3);ts.add(student4);ts.add(student5);//遍历输出集合System.out.println("方法一：默认排序规则/自然排序:");Iterator<Student6> it = ts.iterator();while (it.hasNext()) {Student6 s = it.next();int num = s.getEnglish() + s.getMath() + s.getChinese();System.out.println(s.getName() + "," + s.getAge() + "," + s.getChinese() + "," + s.getMath() + "," + s.getEnglish() + "," + num);}/*张三,15,99,98,90,287王五,16,95,96,85,276赵六,19,93,68,83,244刘备,12,75,68,73,216李四,14,79,56,36,171*/}
}class Student6 implements Comparable<Student6> {private String name;private int age;private int Chinese;private int Math;private int English;public Student6() {}public Student6(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 "Student6{name = " + name + ", age = " + age + ", Chinese = " + Chinese + ", Math = " + Math + ", English = " + English + "}";}@Override//this:要添加的数据//o：红黑树中已经存在的数据public int compareTo(Student6 o) {//定义变量记录红黑树中已经存入的数据的成绩总和int sum = o.getChinese() + o.getMath() + o.getEnglish();//定义变量记录要添加的数据的成绩总和int sum1 = this.getChinese() + this.getMath() + this.getEnglish();//按照总分从高到低输出到控制台int i = sum - sum1;//如果总分一样，按照语文成绩排i = i == 0 ? o.getChinese() - this.getChinese() : i;//如果语文一样，按照数学成绩排i = i == 0 ? o.getMath() - this.getMath() : i;//如果数学一样，按照英语成绩排i = i == 0 ? o.getEnglish() - this.getEnglish() : i;//如果英语一样，按照年龄排i = i == 0 ? o.getAge() - this.getAge() : i;//如果年龄一样，按照姓名首字母排i = i == 0 ? o.getName().compareTo(this.getName()) : i;//返回值：//负数：表示当前要添加的数据是小的，存左边//正数：表示当前要添加的数据是大的，存右边//0：表示当前要添加的元素已经存在，舍弃return i;}
}

输出结果

4.2 比较器排序

4.2.1 概述

比较器排序是一种在不修改元素的类定义或实现Comparable接口的情况下，通过提供一个独立的比较器来排序元素的方法。

在Java中，比较器（Comparator）是一个可以自定义排序规则的对象，实现了Comparator接口。通过使用比较器，可以按照自己定义的排序方式对元素进行排序，而不依赖于元素自身的特性或默认的自然排序规则。

使用比较器进行排序的过程如下：

创建一个实现了Comparator接口的比较器类，其中包含compare()方法的实现。此方法定义了排序规则。
使用比较器对象创建一个集合（如TreeSet、PriorityQueue等）或者使用比较器作为参数调用排序方法（如Arrays.sort()）。
比较器会根据自定义的排序规则对集合中的元素进行排序。

4.2.2 compare()方法

比较器排序常用的方法是compare()方法，该方法接受两个参数，用于比较两个元素的顺序。
compare()方法是Comparator接口中定义的方法，用于比较两个对象的顺序。它的方法签名如下：

int compare(T obj1, T obj2)

其中，T表示要比较的对象的类型。compare()方法接受两个参数obj1和obj2，分别表示要比较的两个对象，返回一个整数值表示它们的顺序关系。

obj1:要添加的元素
obj2：红黑树中已经存在的数据

compare()方法返回的整数值有以下三种情况：

当compare()方法返回一个负数时，表示第一个元素应排在前面；
当返回0时，表示两个元素相等；
当返回一个正数时，表示第一个元素应排在后面。

具体返回的值大小并不重要，只有它们的正负号和零的关系才有意义。返回的值为负，obj1就越应该排在obj2之前；返回的值为正，obj1就越应该排在obj2之后。

4.2.3 代码示例1

代码示例1：
需求：请自行选择比较器排序和自然排序两种方式；
要求：存入是个字符串： “c”,“ab”,“df”,“qwer”，按照长度排序，如果一样长则按照首字母进行排序

package text.text02;import java.util.Comparator;
import java.util.TreeSet;/* 方法二：比较器排序方法一：默认排序规则/自然排序JavaBean类实现Comparable接口指定比较规则（重写里面的抽象方法，再比较）
方法二：比较器排序创建TreeSet对象时候，传递比较器Comparator指定规则TreeSet对象排序练习题：需求：请自行选择比较器排序和自然排序两种方式；要求：存入是个字符串： "c","ab","df","qwer"，按照长度排序，如果一样长则按照首字母进行排序*/
public class text42 {public static void main(String[] args) {//创建未排序的集合对象TreeSet<String> ts1 = new TreeSet<>();//添加元素ts1.add("c");ts1.add("ab");ts1.add("df");ts1.add("qwer");//输出未排序的集合System.out.println("输出未排序的集合:" + ts1);       //输出未排序得到集合:[ab, c, df, qwer]// 创建排序的集合对象// 创建TreeSet对象时候，传递比较器Comparator指定规则//o1:表示当前要添加的元素//o2：表示已经在红黑树存在的元素//返回值：//负数：表示当前要添加的数据是小的，存左边//正数：表示当前要添加的数据是大的，存右边//0：表示当前要添加的元素已经存在，舍弃TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {//按照长度排序int i = o1.length() - o2.length();//长度一样则按照首字母进行排序i = i == 0 ? o1.compareTo(o2) : i;return i;}});//添加元素ts2.add("c");ts2.add("ab");ts2.add("df");ts2.add("qwer");//输出排序的集合System.out.println("输出排序的集合:" + ts2);      //输出排序的集合:[c, ab, df, qwer]}
}

输出结果

在这里插入图片描述

4.2.4 代码示例2

代码示例2：
求：创建5个学生对象
属性：姓名、年龄，语文成绩。数学成绩、英语成绩
要求：按照总分从高到低输出到控制台
如果总分一样，按照语文成绩排
如果语文一样，按照数学成绩排
如果数学一样，按照英语成绩排
如果英语一样，按照年龄排
如果都一样，认为是同一个学生，不存

package text.text02;import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;/*
TreeSet对象排序练习题：
需求：创建5个学生对象
属性：姓名、年龄，语文成绩。数学成绩、英语成绩
要求：按照总分从高到低输出到控制台如果总分一样，按照语文成绩排如果语文一样，按照数学成绩排如果数学一样，按照英语成绩排如果英语一样，按照年龄排如果都一样，认为是同一个学生，不存*///方法二：比较器排序
//       创建TreeSet对象时候，传递比较器Comparator指定规则public class text44 {public static void main(String[] args) {//创建5个学生对象Student5 student1 = new Student5("张三", 15, 99, 98, 90);Student5 student2 = new Student5("李四", 14, 79, 56, 36);Student5 student3 = new Student5("王五", 16, 95, 96, 85);Student5 student4 = new Student5("赵六", 19, 93, 68, 83);Student5 student5 = new Student5("刘备", 12, 75, 68, 73);//创建集合TreeSet<Student5> ts = new TreeSet<>(new Comparator<Student5>() {@Override//o2:红黑树中已经存在的数据//o1:要添加的数据public int compare(Student5 o1, Student5 o2) {//定义变量记录红黑树中已经存入的数据的成绩总和int sum = o2.getChinese() + o2.getMath() + o2.getEnglish();//定义变量记录要添加的数据的成绩总和int sum1 = o1.getChinese() + o1.getMath() + o1.getEnglish();//按照总分从高到低输出到控制台int i = sum - sum1;//如果总分一样，按照语文成绩排i = i == 0 ? o2.getChinese() - o1.getChinese() : i;//如果语文一样，按照数学成绩排i = i == 0 ? o2.getMath() - o1.getMath() : i;//如果数学一样，按照英语成绩排i = i == 0 ? o2.getEnglish() - o1.getEnglish() : i;//如果英语一样，按照年龄排i = i == 0 ? o2.getAge() - o1.getAge() : i;//如果年龄一样，按照姓名首字母排i = i == 0 ? o2.getName().compareTo(o1.getName()) : i;//返回值：//负数：表示当前要添加的数据是小的，存左边//正数：表示当前要添加的数据是大的，存右边//0：表示当前要添加的元素已经存在，舍弃return i;}});//添加学生对象ts.add(student1);ts.add(student2);ts.add(student3);ts.add(student4);ts.add(student5);//遍历输出集合System.out.println("方法二：比较器排序:");Iterator<Student5> it = ts.iterator();while (it.hasNext()) {Student5 s = it.next();int num = s.getEnglish() + s.getMath() + s.getChinese();System.out.println(s.getName() + "," + s.getAge() + "," + s.getChinese() + "," + s.getMath() + "," + s.getEnglish() + "," + num);}/*张三,15,99,98,90,287王五,16,95,96,85,276赵六,19,93,68,83,244刘备,12,75,68,73,216李四,14,79,56,36,171*/}
}class Student5 {private String name;private int age;private int Chinese;private int Math;private int English;public Student5() {}public Student5(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 "Student5{name = " + name + ", age = " + age + ", Chinese = " + Chinese + ", Math = " + Math + ", English = " + English + "}";}
}

输出结果

4.3 排序方式的对比

定义方式：

自然排序：通过实现Comparable接口，在类的定义中定义排序规则。
比较器排序：通过实现Comparator接口，在类的外部提供一个独立的比较器对象定义排序规则。

依赖性：

自然排序：依赖于类的定义，对象必须实现Comparable接口来定义默认的自然排序规则。
比较器排序：不依赖于类的定义，可以根据不同的排序需求提供不同的比较器对象。

修改类定义：

自然排序：需要修改类的定义，将实现Comparable接口，并重写compareTo()方法来定义排序规则。
比较器排序：无需修改类的定义，可以提供一个独立的比较器对象来定义排序规则，对类的定义没有侵入性。

灵活性：

自然排序：对于具体的类，只能有一种自然排序规则，不易灵活更改。
比较器排序：可以根据具体的使用需求，提供不同的比较器对象，灵活定义不同的排序规则。

使用场景：

自然排序：适用于类的默认排序需求，可以直接使用已定义的自然排序规则进行排序。
比较器排序：适用于自定义的排序需求，或者需要对无法修改类定义的类进行排序。

5. 注意事项

元素的可比较性：TreeSet是基于红黑树实现的有序集合，要保证集合中的元素是可比较的，即元素类必须实现Comparable接口或传入一个比较器（Comparator）对象来比较元素的顺序。
元素的唯一性：TreeSet不允许重复的元素存在。在插入新元素时，TreeSet会根据元素的比较规则判断是否已经存在相同的元素，如果存在，则新元素不会被插入。
性能：由于TreeSet是基于红黑树实现的，插入、删除和查找操作的时间复杂度都是O(logN)，其中N是集合中元素的个数。这使得TreeSet在大多数情况下具有较好的性能。但是，与HashSet相比，在非排序需求的情况下，HashSet具有更好的性能。
无法使用null元素：TreeSet不允许使用null元素。由于TreeSet需要比较元素，并将其放入正确的位置，如果集合中出现null元素，则无法确定其正确的位置，因此会抛出NullPointerException。
自然顺序和比较器：TreeSet可以使用元素类的自然顺序（如果元素类实现了Comparable接口），也可以通过传入一个比较器对象来定义元素的顺序。在创建TreeSet时，可以选择传入一个Comparator对象来进行自定义的排序比较。