【自然排序】
package com.hxl;
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
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 int compareTo(Student s) {
// 先让两个对象的age属性做差比较，这个是主要排序条件
int num = this.age - s.age;
// 若age属性相同，再比较name属性(String类本身实现了Comparable接口)
// 即在主要排序条件相同的情况下，次要排序条件起作用
int flag = num == 0 ? this.name.compareTo(s.name) : num;
// 返回比较结果
return flag;
}
}
package com.hxl;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
//这里使用的无参构造实例化TreeSet集合，则默认启用的是自然排序
TreeSet<Student> ts = new TreeSet<Student>();
ts.add(new Student("cc", 11));
ts.add(new Student("ee", 11));
ts.add(new Student("cc", 22));
ts.add(new Student("aa", 22));
ts.add(new Student("bb", 11));
for (Student s : ts) {
System.out.println(s.getName()+"_"+s.getAge());
}
/*
为什么TreeSet集合中的元素既唯一又有序呢？
原因是它在存储元素的时候就是有序存储的（红黑树结构存储）
TreeSet的add()方法底层依赖的是Comparable的compareTo方法
这里就是说元素类本身要有自己的compareTo方法
所以元素类本身必须实现Comparable接口，重写compareTo方法
compareTo方法有个特点：它返回的是int型数据，结果有三类负数、0、正数
例如：(Java中一些常见的有比较意义的一些类都实现了Comparable接口，如Integer类)
Integer a = new Integer(10);
Integer b = new Integer(20);
int num = a.compareTo(b); //因为a小于b，所以num返回的是负数
而TreeSet的add()方法这样理解此返回值：
即返回负数则比根节点小，元素在此集合中唯一，元素存放根的左孩子
返回正数则比根节点大，元素在此集合中唯一，元素存放根的右孩子
返回0则表示，元素相同，在此集合中不唯一，故而丢掉不存放
由此可见，我们的重写的compareTo()方法决定了TreeSet集合中元素的去留和顺序！
*/
}
}
【比较器排序（外部类实现）】
package com.hxl;
public class Student{
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
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;
}
}
package com.hxl;
import java.util.Comparator;
public class MyComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
// 先让两个对象的age属性做差比较，这个是主要排序条件
int num = s1.getAge() - s2.getAge();
// 若age属性相同，再比较name属性(String类本身实现了Comparable接口)
// 即在主要排序条件相同的情况下，次要排序条件起作用
int flag = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
// 返回比较结果
return flag;
}
}
package com.hxl;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
//这里使用TreeSet(Comparator comparator)构造实例化TreeSet集合，则启用的是指定比较器排序
TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());
ts.add(new Student("cc", 11));
ts.add(new Student("ee", 11));
ts.add(new Student("cc", 22));
ts.add(new Student("aa", 22));
ts.add(new Student("bb", 11));
for (Student s : ts) {
System.out.println(s.getName()+"_"+s.getAge());
}
}
}
【比较器排序（内部类实现，如果只使用一次的话）】
package com.hxl;
public class Student{
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
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;
}
}
package com.hxl; import java.util.Comparator;
import java.util.TreeSet; public class Test {
public static void main(String[] args) {
//如果一个方法的参数是接口，那么真实想要的是其实是接口实现类的对象
//这里的对象只用一次，专门定义一个外部类显得麻烦
//匿名内部类可以实现这个需求
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>(){
public int compare(Student s1, Student s2) {
// 先让两个对象的age属性做差比较，这个是主要排序条件
int num = s1.getAge() - s2.getAge();
// 若age属性相同，再比较name属性(String类本身实现了Comparable接口)
// 即在主要排序条件相同的情况下，次要排序条件起作用
int flag = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
// 返回比较结果
return flag;
}
});
ts.add(new Student("cc", 11));
ts.add(new Student("ee", 11));
ts.add(new Student("cc", 22));
ts.add(new Student("aa", 22));
ts.add(new Student("bb", 11)); for (Student s : ts) {
System.out.println(s.getName()+"_"+s.getAge());
}
}
}
【注】开发中会用最后一种，因为第一种只有固定的排序方式，第二种每次都要定义外面类显得麻烦。