自定义类的对象作为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);
    }
}

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

最终结果为：

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

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