前言
排序可谓是TreeSet集合一大难点,重点了
基本类型
默认以升序的方式排序
//创建一个TreeSet集合
TreeSet<String> ts =new TreeSet<>();
//添加String
ts.add("zs");
ts.add("ls");
ts.add("wu");
ts.add("kc");
for (String t : ts) {
//按照字典顺序,升序
System.out.println(t);
}
System.out.println("===============");
TreeSet<Integer> ts2 = new TreeSet<>();
ts2.add(100);
ts2.add(500);
ts2.add(50);
ts2.add(30);
ts2.add(40);
ts2.add(40);
for (Integer integer : ts2) {
System.out.println(integer);
}
自定义类
自然排序
自定义类
//放在TreeSet集合中的元素需要实现java.lang.Comparable接口
//并且实现compareTo方法
class Customer implements Comparable<Customer>{
int age;
public Customer(int age) {
this.age = age;
}
@Override
public int compareTo(Customer c) {
int age=this.age-c.age;
return age;
}
@Override
public String toString() {
return "Customer{" +
"age=" + age +
'}';
}
}
测试
package com.javase.test.TreeSet;
import java.util.TreeSet;
public class TreeSetTest05 {
public static void main(String[] args) {
Customer c1 = new Customer(21);
Customer c2 = new Customer(41);
Customer c3 = new Customer(23);
Customer c4 = new Customer(22);
Customer c5 = new Customer(29);
TreeSet<Customer> c =new TreeSet<>();
//添加元素
c.add(c1);
c.add(c2);
c.add(c3);
c.add(c4);
c.add(c5);
//遍历
for (Customer customer : c) {
System.out.println(customer);
}
}
}
比较器排序
自定义类
//自定义类
class Student{
int age;
public Student(int age) {
this.age = age;
}
@Override
public String toString() {
return "student{" +
"age=" + age +
'}';
}
}
自定义比较器
class StudentComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
//按年龄排序
int age=o2.age- o1.age;
return age;
//
}
}
测试
public class TreeSetTest07 {
public static void main(String[] args) {
//创建集合对象,并给构造函数传一个比较器
TreeSet<Student> students = new TreeSet<>(new StudentComparator());
//添加对象
students.add(new Student(51));
students.add(new Student(11));
students.add(new Student(1));
students.add(new Student(31));
students.add(new Student(46));
for (Student student : students) {
System.out.println(student);
}
}
}
还可用匿名内部类的方式使用比较器排序
public class TreeSetTest07 {
public static void main(String[] args) {
//匿名内部类
TreeSet<Bird> birds = new TreeSet<>(new Comparator<Bird>() {
@Override
public int compare(Bird o1, Bird o2) {
return o1.age-o2.age;
}
});
birds.add(new Bird(51));
birds.add(new Bird(11));
birds.add(new Bird(1));
birds.add(new Bird(31));
birds.add(new Bird(46));
for (Bird bird : birds) {
System.out.println(bird);
}
}
}
用法
~当比较规则不会发生改变的时候,或者说当比较规则只有1个的时候,建议实现Comparable接口。
~如果比较规则有多个,并且需要多个比较规则之间频繁切换,建议使用comparator接口。