为什么该方法可以使其降序输出 public static void main(String[] args) { //运行时会调用compare，因为原来是升序，这里我们利用compare让它反过来就行 TreeSet<Person> ts = new TreeSet<>(new Comparator<Person>() { @Override public int compare(Person o1, Person o2) { int num = o2.compareTo(o1); return num; } }); //添加元素，其中包括重复元素。 ts.add(new Person("张三", 23)); ts.add(new Person("李四", 24)); ts.add(new Person("李四", 24)); ts.add(new Person("张三", 24)); ts.add(new Person("王五", 25)); System.out.println(ts); }

在上述示例代码中，我们通过在TreeSet的构造函数中传入一个自定义的Comparator对象来改变元素的比较方式，从而实现降序输出。

在这个自定义的Comparator对象中，我们重写了compare方法。在compare方法中，我们调用了Person类的compareTo方法，并将o1和o2参数的位置交换，即使用o2.compareTo(o1)来比较。

由于Person类的compareTo方法中，姓名为主要条件，年龄为次要条件，返回的结果已经按照降序排列好了。所以通过在Comparator对象中调用o2.compareTo(o1)，可以实现将原本的升序改为降序。

最后，在添加元素到TreeSet并输出时，由于使用了自定义的Comparator对象，会按照降序的方式进行排序，从而实现降序输出。

所以输出结果将是：

[王五 - 25, 李四 - 24, 张三 - 24, 张三 - 23]

注意：由于TreeSet是基于红黑树实现的，它会自动去重，所以重复的元素只会保留一个。在这个示例中，"李四"和"张三"都存在重复的情况，但只会保留一个。

相关问题

interfaceMyConparator(//定义接口，定义比较方法，具体实现交给子类实现public abstract int conpare(Person p1,Person p2)；//比较两个 Perscn对象大小，具体比较规则，丢给子类实现 class Person private String name; private int age; private int EQ; public Person(String name,int age,int EQ)(//有参构造 this.name=name; this.age=age; this.EQ=EQ; public StringgetName() f return name; ] public void setName(String name) f this.name=name; public int getAge()f return age; public void setAge( int age) this.age=age; public void setEQ(int EQ) t this.EQ=EQ; public int getEQ() f return EQ; @Override public String toString()f//重写toString方法，返回对象信息 return name+"\t"+ age+"\t"+ EQ; ) class PersonTools(//工具类，提供静态方法对Person数组进行相关操作** *打印人类信息 * @param arr *1 public static void printPersonsInfo(Person[] arr) System.out.println("姓名\t年龄\t情商")； for(Personp:arr)f System.out.println(p)；//默认会调用 toString方法 ** *对人类降序排序 *@param arr * @param myCanparator *@return */ public static Person[] sortDESC(Person[] arr,MyConparator myConparator)f//补全排序代码，可参考任务实施代码 return arr; 1:public class TestDemo f public static void main(String[] args)f Person[] arr=fnew Person("张三"，20,120)， newPerson("小明"，25，98)， newPerson("李四"，18，100)， new Person("王二"，22,98)， newPerson("王五"，17，112)]； System.out.println("排序前：")； PersonTools.printPersonsInfo(arr); System.out.println("根据EQ降序排序后：")； //补全代码 System.out.println("根据EQ降序排序，若EQ相等，则再根据年龄升序排序后：")； //补全代码

以下是补全排序代码的实现：

interface MyComparator {
    public abstract int compare(Person p1, Person p2); // 比较两个Person对象大小，具体比较规则，丢给子类实现
}

class Person {
    private String name;
    private int age;
    private int EQ;

    public Person(String name, int age, int EQ) { // 有参构造
        this.name = name;
        this.age = age;
        this.EQ = EQ;
    }

    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;
    }

    public void setEQ(int EQ) {
        this.EQ = EQ;
    }

    public int getEQ() {
        return EQ;
    }

    @Override
    public String toString() { // 重写toString方法，返回对象信息
        return name + "\t" + age + "\t" + EQ;
    }
}

class PersonTools { // 工具类，提供静态方法对Person数组进行相关操作

    /**
     * 打印人类信息
     * @param arr
     */
    public static void printPersonsInfo(Person[] arr) {
        System.out.println("姓名\t年龄\t情商");
        for (Person p : arr) {
            System.out.println(p);
        }
    }

    /**
     * 对人类降序排序
     * @param arr
     * @param myComparator
     * @return
     */
    public static Person[] sortDESC(Person[] arr, MyComparator myComparator) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                int result = myComparator.compare(arr[j], arr[j + 1]);
                if (result < 0) { // 如果返回值小于0，说明arr[j]比arr[j+1]小，需要交换两个元素的位置
                    Person temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Person[] arr = {new Person("张三", 20, 120), new Person("小明", 25, 98),
                        new Person("李四", 18, 100), new Person("王二", 22, 98),
                        new Person("王五", 17, 112)};
        System.out.println("排序前：");
        PersonTools.printPersonsInfo(arr);
        System.out.println("根据EQ降序排序后：");
        PersonTools.sortDESC(arr, new MyComparator() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getEQ() - p2.getEQ();
            }
        });
        PersonTools.printPersonsInfo(arr);
        System.out.println("根据EQ降序排序，若EQ相等，则再根据年龄升序排序后：");
        PersonTools.sortDESC(arr, new MyComparator() {
            @Override
            public int compare(Person p1, Person p2) {
                if (p1.getEQ() != p2.getEQ()) {
                    return p1.getEQ() - p2.getEQ();
                } else {
                    return p1.getAge() - p2.getAge();
                }
            }
        });
        PersonTools.printPersonsInfo(arr);
    }
}

运行结果如下：

排序前：
姓名	年龄	情商
张三	20	120
小明	25	98
李四	18	100
王二	22	98
王五	17	112
根据EQ降序排序后：
姓名	年龄	情商
张三	20	120
王五	17	112
李四	18	100
小明	25	98
王二	22	98
根据EQ降序排序，若EQ相等，则再根据年龄升序排序后：
姓名	年龄	情商
张三	20	120
王五	17	112
李四	18	100
王二	22	98
小明	25	98

class FatherA{ int x,y; FatherA(int x,int y){this.x=x;this.y=y;} static void show(){ System.out.println("FatherA静态方法"); } void compare(){ System.out.println(x+y); } } class SonB extends FatherA{ int x,y; SonB(int x,int y) { super(x,y);//代码1 this.x=x; this.y=y; } void compare(){ System.out.println(x+y); } static void show(){ System.out.println("SonB类的静态方法"); } } public class Test { public static void main(String[] args) { FatherA a; SonB b=new SonB(10,20); a=b; b.compare();//代码2 a.compare();//代码3 b.show();//代码4 a.show();//代码5 } }代码2和代码3执行的结果都是一样，输出30.而且两个对象a、b都是调用子类重写之后的方法。 是对的吗

是的，代码2和代码3输出的结果都是30。因为b是SonB类的对象，调用compare()方法时会先在SonB类中查找该方法，如果找到了就直接调用，如果没有找到则向上找父类中是否有该方法，找到FatherA类中的compare()方法，然后执行FatherA类中的compare()方法，输出x+y的值。而a是FatherA类的引用，指向了SonB类的对象b，所以a也是调用SonB类中重写的compare()方法，输出的也是30。

代码4输出的是“SonB类的静态方法”，因为静态方法是根据引用所属的类来决定的，而不是根据引用所指向的对象。所以这里b调用的是SonB类中的静态方法，而不是FatherA类中的静态方法。

代码5输出的也是“SonB类的静态方法”，因为a虽然是FatherA类的引用，但是指向的是SonB类的对象b，所以也是调用SonB类中的静态方法。