自定义类的对象作为TreeSet元素的两种方法排序浅谈

我们知道TreeSet是Set接口下的一个实现类，TreeSet中的元素的排列顺序是和添加的顺序是没有关系的，并且它里面元素也是不能重复的

但是，TreeSet集合有它独有的特点，比如：

import java.util.*;
public class Test{
public static void main(String[] args){
TreeSet ts = new TreeSet();
ts.add("x");
ts.add("a");
ts.add("c");
ts.add("j");
System.out.println(ts);
}
}

看输出结果：



集合里元素的排序，虽然和你添加的顺序无关，但它会根据元素的unicode自然排序

但是，当你给集合中添加不同类型的数据时：

import java.util.*;
public class Test{
public static void main(String[] args){
TreeSet ts = new TreeSet();
ts.add("x");
ts.add("a");
ts.add("c");
ts.add(１);
System.out.println(ts);
}
}

出现的结果是：



就会报ClassCastException 类型转换异常

String 不能转成Integer类型，要排序，类型必须一致

说了这么多，TreeSet的排序好像就这么多了？？

当然不是了，再往下看：

如果现在给集合里添加自定义类的对象怎么办？它又是怎么排序的呢？

import java.util.*;

class Person{
private String name ;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return "Person[name="+name+",age="+age+"]";
}
}
public class Test{
public static void main(String[] args){
TreeSet ts = new TreeSet();
ts.add(new Person("ab",20));
ts.add(new Person("ac",10));
ts.add(new Person("aa",20));
ts.add(new Person("ad",50));
System.out.println(ts);
}
}

再看运行结果：



可以看出，给出的异常信息是：Person类不能比较，为什么呢？

它给的异常信息指示是应该去实现Comparable接口，一般系统内置的类都已经实现了Comparable接口，像上面的String类，Integer类

不卖关子了，说一下，自定义类的对象作为TreeSet元素的两种方法排序：

第一种：让自定义的类实现Comparable接口，并实现里面的compareTo()抽象方法，此时自定义的类的对象就有了可比性

第二种：当自定义的类没有实现Comparable接口时，这时自定义的类的对象也就不具备可比性了，这时需要让集合自身具备可比性，在集合初始化时，可以指明集合的比较方式，即在new TreeSet()时，在里面写一个匿名内部类，该匿名内部类实现Comparator接口，再重写它的compare()方法，具体看代码

先看第一种：

看下面的代码，排序规则是自定义的，先按照年龄排序，在年龄相同的情况下，再按名字排序

import java.util.*;
class Person implements Comparable{
private String name ;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return "Person[name="+name+",age="+age+"]";
}
// compareTo()方法是一个回调方法!
// 返回值有3种情况：
// 1. 返回大于0的数字，表示传入的参数比当前对象大
// 2. 返回小于0的数字，表示传入的参数比当前对象小
// 3. 返回0，表示当前对象等于传入的参数
public int compareTo(Object obj){
if(!(obj instanceof Person)){
//这里先判断Obj是不是Person的实例，如果不是直接抛异常
//不用再进行下面的比较
throw new ClassCastException("这不是人");
}
Person p = (Person)obj;
int n = this.age - p.age;
//先按年龄比，年龄相同时，再按名字比
if(n == 0){
return this.name.compareTo(p.name);
}
return n;
}
}
public class Test{
public static void main(String[] args){
Set set = new TreeSet();
set.add(new Person("ab",20));
set.add(new Person("ac",10));
set.add(new Person("aa",20));
set.add(new Person("ad",50));
System.out.println(set);
}
}

看输出结果：



看中间两项，当年龄相同，都是20，此时，两者再按照名字排序

第二种：

此时，不实现Comparable接口，在new TreeSet()时，在里面写一个匿名内部类，该匿名内部类实现Comparator接口，再重写它的compare()方法

import java.util.*;
class Person{
private String name ;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return "Person[name="+name+",age="+age+"]";
}
public int getAge(){
return age;
}
public String getName(){
return name;
}
}
public class Test{
public static void main(String[] args){
Set set = new TreeSet(new Comparator(){
//这里的compare()传两个参数
//第一种方法里的compareTo()传一个参数
public int compare(Object obj1,Object obj2){
if(!((obj1 instanceof Person)&&(obj1 instanceof Person))){
throw new ClassCastException("这不是人");
}
Person p1 = (Person)obj1;
Person p2 = (Person)obj2;
System.out.println(p1 + "vs" + p2);
return p1.getAge()-p2.getAge();
}
});
set.add(new Person("ab",20));
set.add(new Person("ac",10));
set.add(new Person("aa",20));
System.out.println(set);
}
}

看输出结果：



最后一行是最终结果，前面三行是比较过程

这里只按照年龄排序，没有再按名字排序，所以最后输出的set只有两项，第三项和第一项重复，直接被过滤掉

注意一点，当两种方法都存在时，到底以哪种方法为主呢？

答案是，以第二种方法，以比较器comparator()为主

我们可以验证一下：看下面，把两个方法都放进去

import java.util.*;
class Person implements Comparable{
//这里实现了Comparable接口
private String name ;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return "Person[name="+name+",age="+age+"]";
}
public int getAge(){
return age;
}
public String getName(){
return name;
}

public int compareTo(Object obj){
if(!(obj instanceof Person)){

throw new ClassCastException("这不是人");
}
Person p = (Person)obj;
int n = this.age - p.age;

if(n == 0){
return this.name.compareTo(p.name);
}
return n;
}
}
public class Test{
public static void main(String[] args){
Set set = new TreeSet(new Comparator(){
//这里也实现了Comparator接口
//那么以哪种为主呢？
//看最下面的结果
public int compare(Object obj1,Object obj2){
if(!((obj1 instanceof Person)&&(obj1 instanceof Person))){
throw new ClassCastException("这不是人");
}
Person p1 = (Person)obj1;
Person p2 = (Person)obj2;
return p1.getAge()-p2.getAge();
}
});
set.add(new Person("ab",20));
set.add(new Person("ac",10));
set.add(new Person("aa",20));

System.out.println(set);
}
}

如果输出的集合中有三项，则说明以第一种为主；

如果输出的集合中有两项，则说明以第二种为主

最终结果为：



输出的只有两项，说明了：当两种排序方式都存在时，以比较器为主

其实第一种方式是有安全隐患的，后续再来完善…..