Java Comparator与Comparable辨析

Comparator与Comparable辨析

声明

文章均为本人技术笔记，转载请注明出处：
[1] https://segmentfault.com/u/yzwall
[2] blog.csdn.net/j_dark/

比较三种状态

根据需求定义“序”（升序 or 降序）；

• LESS_THAN： 返回负数，表示比较两元素满足序，无须调整，；

• EQUAL：返回0，表示比较两元素“相等”，无须调整位置，；

• GREATER_THAN：返回正数，表示比较两元素不满足序，按序调整位置；

对象内部排序：Comparable<T>

Comparable<T>源码

// full name: java.lang.Comparable<T>
public interface Comparable<T> {
    public int compareTo(T o);
}

继承Comparable<T>接口的对象必须重写compareTo方法，实现对象内部排序；
目前所有的包装类和String类都实现了Comparable<T>接口；

Comparable实现示例

class Student implements Comparable<Student>{
    private static final int LESS_THAN =  -1;
    private static final int EQUAL =  0;
    private static final int GREATER_THAN =  1;
    int age;
    int id;
    
    ...
    @Override
    // 按照age升序排练，age相等按照id降序排练
    public int compareTo(Student o) {
        if (this.age < o.age) {
            return LESS_THAN;
        } 
        if (this.age ==  o.age) {
            return this.id > o.id ? LESS_THAN : (this.id == o.id) ? EQUAL : GREATER_THAN;
        } else {
            return GREATER_THAN;
        }
    }
    ...
}

根据Comparable排序

集合或数组元素实现Comparable<T>接口，通过以下两种方式实现排序：
集合排序：Collections.sort(List<T> list)，底层调用Arrays.sort()实现；
数组排序：Arrays.sort(T[] arr)；

对象外部排序：Comparator<T>

Comparator<T>源码

public interface Comparator<T> {
    ...
    // 重写compare比较规则，通过外部传入实现自定义排序
    int compare(T o1, T o2);
}

Comparator实现示例

/**
 * 集合排序：Colletions.sort(list, new MyComparator());
 * 数组排序：Arrays.sort(arr, new MyComparator());
 */
class MyComparator implements Comparator<Student> {
    private static final int LESS_THAN =  -1;
    private static final int EQUAL =  0;
    private static final int GREATER_THAN =  1;
    
    @Override
    // 按照age降序排练，age相等按照id升序排练
    public int compare(Student a, Student b) {
        if (a.age > b.age) {
            return LESS_THAN;
        } 
        if (a.age ==  b.age) {
            return a.id < b.id ? LESS_THAN : (a.id == b.id) ? EQUAL : GREATER_THAN;
        } else {
            return GREATER_THAN;
        }
    }
}

根据Comparator排序

Comparator体现了策略设计模式，即不改变对象自身，而使用一个策略对象去改变它的行为。

集合或数组元素实现Comparator<T>接口，通过以下两种方式实现排序：
集合排序：Collections.sort(List<T> list， new Comparator<T>)，底层调用Arrays.sort(T[] arr, Comparator<? super T> c)实现；
数组排序：Arrays.sort(T[] arr, Comparator<? super T> c)；

Comparator<T>与Comparable<T>辨析

Comparable<T>与Comparator<T>都是用于对集合或数组元素的排序比较，

• Comparable<T>面向对象，对象重写compareTo方法即可在内部完成比较，更改比较逻辑时只能更改对象自身（比如通过Comparable接口无法改变包装类型和String类型的比较规则）；

• Comparator<T>面向集合/数组，在外部自定义比较器实现接口，传入集合/数组内部提供比较，更改比较逻辑时只需更改自定义比较器，无须更改对象，应用更广泛；

参考

[1] http://blog.csdn.net/mageshuai/article/details/3849143