Java比较器

转载修改自https://www.cnblogs.com/deityjian/p/11370630.html

常见比较器Comparable和Comparator

Comparable和Comparator都是java.包下的两个接口

Comparable和Comparator接口都是为了对类进行比较，像Integer，double等基本数据类型，java可以对他们进行比较，而对于类的比较，需要人工定义比较用到的字段比较逻辑。

一、Comparable

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的
若一个类实现了Comparable接口，就意味着该类支持排序。
实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。

1.1 Comparable接口

public interface Comparable<T> {
    // 这里入参也是T  所以是自己和自己比较的
    // 规则：this和t比较。  返回0表示两个对象相等
    // 返回正数： this > o
    // 返回负数： this < o
    public int compareTo(T o);
}

1.2 定义一个Person对象类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person implements Comparable{
    private int id;
    private String name;
    
    @Override
    public int compareTo(Object o) {
        Person p = (Person) o;
        return this.getId()>p.getId()?1:(this.getId()==p.getId()?0:-1);
    }
}

1.3 排序

public static void main(String[] args) {
        List<Person> peoples = new ArrayList<Person>();
        peoples.add(new Person(1,"a1"));
        peoples.add(new Person(3,"a3"));
        peoples.add(new Person(6,"a6"));
        peoples.add(new Person(2,"a2"));
        Collections.sort(peoples);
        System.out.println(peoples);

        Person[] pp = {new Person(3,"b3"),new Person(2,"b2")};
        Arrays.sort(pp);
        System.out.println(Arrays.toString(pp));
    }

二、Comparator

Comparator是比较接口，我们如果需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)，那么我们就可以建立一个“该类的比较器”来进行排序，这个“比较器”只需要实现Comparator接口即可。
使用场景：
- 对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较（大都是这种情况）
- 对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式
若一个类要实现Comparator接口：它一定要实现compare(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。
- int compare(T o1, T o2) 是“比较o1和o2的大小”。
- 返回“负数”，意味着“o1比o2小”；
- 返回“零”，意味着“o1等于o2”；
- 返回“正数”，意味着“o1大于o2”。

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2); 
    boolean equals(Object obj);
    //....还有其他很多方法
}

2.1实现方式

我们在某段代码中只需要用到一次比较，可以直接使用匿名内部类。如果我们需要经常用到一个对象类的比较，可以写一个专门的比较器工具类，这个比较器工具类可以写复杂的排序，二次比较等自定义的比较，

匿名内部类

Collections.sort(peoples, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
System.out.println("#匿名内部类# " + peoples);

另外写一个通用的比较工具类

PersonComparator比较类实现了Comparator

public class PersonComparator implements Comparator<Person> {

    String orderby;
    String orderType;
    public PersonComparator(String  orderby,String orderType) {
        this.orderby = orderby;
        this.orderType = orderType;
    }

    @Override
    public int compare(Person o1, Person o2) {
        int result = 0;
        if ("id".equals(orderby)) {
            result = o1.getId()>o2.getId()?1:(o1.getId()==o2.getId()?0:-1);
        }
        if ("name".equals(orderby)) {
            result = o1.getName().compareTo(o2.getName());
        }
        if ("DESC".equals(orderType)) {
            result = 0 - result;
        }
        return result;
    }
}

使用比较工具类PersonComparator

Collections.sort(peoples, new PersonComparator("name","ASC"));
System.out.println("#PersonComparator类# " + peoples);

可以按照我们自己定义的比较器排序。并且Person是没有实现排序接口的哦，所以是没有入侵性的。

三、Comparable和Comparator区别比较

Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。
而Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
用Comparable 简单，只要实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。(有侵入性)
用Comparator 的好处是不需要修改源代码，而是另外实现一个比较器，当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了，并且在Comparator里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。

四、其他

Comparator接口中的默认方法和静态方法

TODO