Comparable与Comparator详解-优快云博客

Comparable和Comparator

对于Comparable和Comparator，默认都是升序排序
区别：
Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：

1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数

2、比较者等于被比较者，那么返回0

3、比较者小于被比较者，那么返回负整数

Comparator可以认为是是一个外比较器，个人认为有两种情况可以使用实现Comparator接口的方式：

1、一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较

2、一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

1、o1大于o2，返回正整数

2、o1等于o2，返回0

3、o1小于o3，返回负整数

内置类的比较

在上一节中，已经说过，引用数据类型已经继承了Comparable接口，可以按照自然规则排序，而对于业务规则，使用Comparable不能排序，这时候就需要借助Comparator，下面通过实例来解释：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Damo01 {
    public static void main(String[] args) {
//      String arr[] = {"a","abc","abe","dce","dcea"};
//      Util.sort(arr);   //注意，必须是静态方法才可以这么调用
//      System.out.println(Arrays.toString(arr));

        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("abc");
        list.add("abe");
        list.add("dce");
        list.add("dcea");
        Util.sort(list,new Lengthcomp()); //按照自定义的业务规则来排序
        System.out.println(list);
//      String arr[] = {"a","abc","ab","dce","dcea"};
//      Util.sort(arr,new Lengthcomp());
//      System.out.println(Arrays.toString(arr));
    }
}

输出为：[dcea, abc, abe, dce, a]

import java.util.Comparator;
import java.util.List;

public class Util {


    //容器排序，使用泛型
    public static <T extends Comparable<T>> void sort(List<T> list,Comparator<T> com){
        //第一步，容器转为数组
        Object[] arr = list.toArray();
        Util.sort(arr,com);
        //第二步，改变容器中对应的值
        for(int i=0;i<arr.length;i++){
            list.set(i, (T)arr[i]);
        }
    }


    //数组排序
    public static void sort(Object[] arr,Comparator com){
    //最终版,从小到大排序
        boolean sorted = true;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(com.compare(arr[j], arr[j+1])>0){
                    Object temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    sorted = false;
                }
            }
            if(sorted){
                break;
            }
        }
    }


    //容器排序，使用泛型
    public static <T extends Comparable<T>> void sort(List<T> list){
        //第一步，容器转为数组
        Object[] arr = list.toArray();
        Util.sort(arr);
        //第二步，改变容器中对应的值
        for(int i=0;i<arr.length;i++){
            list.set(i, (T)arr[i]);
        }
    }


    //数组排序，使用泛型
    public static <T extends Comparable<T>> void sort(T arr[]){
        //最终版,从小到大排序
        boolean sorted = true;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(((Comparable)arr[j]).compareTo(arr[j+1])>0){
                    T temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    sorted = false;
                }
            }
            if(sorted){
                break;
            }
        }
    }

    //数组排序
    public static void sort(Object arr[]){
        //最终版,从小到大排序
        boolean sorted = true;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(((Comparable)arr[j]).compareTo(arr[j+1])>0){
                    Object temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    sorted = false;
                }
            }
            if(sorted){
                break;
            }
        }
    }
}

import java.util.Comparator;
//自定义业务规则，按照字符串的长度来排序
public class Lengthcomp implements Comparator<String>{

    @Override
    public int compare(String o1, String o2) {
        int len1 = o1.length();
        int len2 = o2.length();
        return -len1+len2;  //本来默认是升序排序，这里加负号表示降序排序
    }

}