# Comparator 接口

考虑一个类 Cat, 拥有两个私有变量 昵称 name，和 年龄 month。我们需要让Cat对象按照 name 进行升序排序，按照 month 进行降序排序。

我们先定义 Cat 类:

```java
public class Cat {

    private String name;
    private int month;

    public Cat(String name, int month) {
        this.name = name;
        this.month = month;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    //重写object类的toString方法，详见java文档 java.base.lang object类
    @Override
    public String toString() {
        return "name=" + name + ", month=" + month ;
    }

}
```

接下来，要定义一个 一个AgeComparator 类 实现 Comparator 接口， 重写 compare 函数，实现对 Cat 对象 按照 age 进行降序排序。

在这个场景中， 我们需要按照 age 进行降序排序。compare 返回 一个负数，若第一个 Cat 对象的 age变量比第二个大， 返回0 则相等，返回 正数 若第一个 Cat 对象的 age 变量比 第二个小。

若为 升序排序，则返回值正负相反。&#x20;

```java
public class AgeComparator implements Comparator<Cat> {

    // 重写compare方法
    // compare(T arg1, T arg2) 返回正数若arg1<arg2, 返回0相等, 返回负数若arg1>arg2
    @Override
    public int compare(Cat o1, Cat o2) {
        int age1 = o1.getMonth();
        int age2 = o2.getMonth();
        
        //因为是降序, 故由参数2-参数1
        return age2 - age1;
    }

}
```

类似的， 我们定义一个 NameComparator 类， 实现Comparator 接口， 重写 compare 函数，实现对 Cat 对象 按照 name 进行升序排序。

```java
public class NameComparator implements Comparator<Cat> {

    // 重写compare方法
    // compare(T arg1, T arg2) 返回负数若arg1<arg2, 返回0相等, 返回正数若arg1>arg2
    @Override
    public int compare(Cat o1, Cat o2) {

        String name1=o1.getName();
        String name2=o2.getName();

        //调用字符串compareTo 方法完成字符串的相减
        int n=name1.compareTo(name2);

        return n;
    }
}
```

最后我们 用一个 CatTest 测试类，测试一下能否实现自定义的 比较。

```java
public class CatTest {
    public static void main(String[] args) {

        Cat huahua = new Cat("huahua", 5 );
        Cat fanfan = new Cat("fanfan", 2 );

        List<Cat> catList = new ArrayList<Cat>();

        catList.add(huahua);
        catList.add(fanfan);

        // 排序前
        System.out.println("按名字排序前:");
        for (Cat cat : catList) {
            System.out.println(cat + " ");
        }
        //输出:
        //按名字排序前:
        //name=huahua, month=5 
        //name=fanfan, month=2 

        System.out.println();

        // 按名字升序排序
        Collections.sort(catList, new NameComparator());

        // 按名字升序排序后
        System.out.println("按名字升序排序后:");
        for (Cat cat : catList) {
            System.out.println(cat + " ");
        }
        //输出:
        //按名字升序排序后:
        //name=fanfan, month=2 
        //name=huahua, month=5 
        System.out.println();

        // 按年龄降序排序
        System.out.println("按年龄排序前:");
        for (Cat cat : catList) {
            System.out.println(cat + " ");
        }
        //输出:
        //按年龄排序前:
        //name=fanfan, month=2 
        //name=huahua, month=5 
        
        System.out.println();

        // 按年龄降序排序
        Collections.sort(catList, new AgeComparator());

        // 按年龄降序排序后
        System.out.println("按年龄降序排序后:");
        for (Cat cat : catList) {
            System.out.println(cat + " ");
        }
        //输出:
        //按年龄降序排序后:
        //name=huahua, month=5 
        //name=fanfan, month=2 
        System.out.println();

    }
}
```
