通过策略模式认识comparable接口与comparator接口

　　comparable接口只是一个引子，引出策略模式中的接口comparator接口

　　comparable接口的演变思想还是有价值去研究的

一.comparable接口演变

演变一：

　　这一版本中运用选择排序实现了一个int类型最基本的排序功能

public class Sorter {

    public static void sort(int[] arr) {
        for (int i=0; i<arr.length - 1; i++){
            int minPoint = i;

            for(int j=i+1; j<arr.length; j++){
                minPoint = arr[j] < arr[minPoint] ? j : minPoint;
            }

            swap(arr, i, minPoint);
        }
    }

    static void swap(int[] arr, int i , int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

public class Main {
    public static void main(String[] args) {
        int[] a = {9,2,3,5,7,1,4};
        Sorter sorter = new Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

　　问一：如果要对float类型的数字进行排序怎么办？对double类型、byte类型呢？

　　　　答：只需要在Sorter类中重写sort方法就能实现

　　问二：如果要对一些引用数据类型进行排序呢？

　　　　答：这一版本肯定是不行的

演变二：

　　接问题二进而有了第二个版本，针对引用数据类型进行排序，我们这里举例Cat

　　那么怎么比较猫的大小呢？这里就需要我们编写方法规定好比较规则了(CompareTo方法)

public class Cat {
    int weight,height;

    public Cat(int weight,int height){
        this.weight = weight;
        this.height = height;
    }

    public int compareTo(Cat cat){
        if (this.weight < cat.weight) return -1;
        else if(this.weight > cat.weight) return 1;
        else return 0;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}

public class Sorter {

    public static void sort(Cat[] arr) {
        for (int i=0; i<arr.length - 1; i++){
            int minPoint = i;

            for(int j=i+1; j<arr.length; j++){
                minPoint = arr[j].compareTo( arr[minPoint] ) == -1 ? j : minPoint;
            }
            swap(arr, i, minPoint);
        }
    }

    static void swap(Cat[] arr, int i , int j){
        Cat temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

public class Main {
    public static void main(String[] args) {
        Cat[] cat = {new Cat(3,3), new Cat(5,5), new Cat(1,1)};
        Sorter sorter = new Sorter();
        sorter.sort(cat);
        System.out.println(Arrays.toString(cat));
    }
}

　　问三：这个版本中我们对Cat类进行了排序，那么如果我要对Dog类、Egg类进行排序怎么办？

　　　　答：我们可以将Sorter类中传入sort方法的参数类型设置为Object类型

　　问四：解决了上面问三，但是Object类中并没有compareTo方法怎么办？

　　　　答：可以新建一个接口，里面定义compareTo方法，所有参与比较的类都要实现该接口

演变三：

　　解决问三、问四问题

public interface Comparable {
    //为了实现多个类共用此方法，这里将传入参数设置为Object类型
    public int compareTo(Object o);
}

public class Sorter {
    //为了实现共用，而将传入参数设置为Comparable
    public static void sort(Comparable[] arr) {
        for (int i=0; i<arr.length - 1; i++){
            int minPoint = i;

            for(int j=i+1; j<arr.length; j++){
                minPoint = arr[j].compareTo( arr[minPoint] ) == -1 ? j : minPoint;
            }
            swap(arr, i, minPoint);
        }
    }

    static void swap(Comparable[] arr, int i , int j){
        Comparable temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

public class Dog implements Comparable {

    int food;

    public Dog(int food){
        this.food = food;
    }

    //这里传入参数为Object类型
    @Override
    public int compareTo(Object o) {
        //这里要使用Dog类型进行转换时，需要将Object类型的参数转换为Dog类型
        Dog dog = (Dog)o;
        if (this.food<dog.food) return -1;
        else if (this.food<dog.food) return 1;
        else return 0;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "food=" + food +
                '}';
    }
}

public class Cat implements Comparable{
    int weight,height;

    public Cat(int weight,int height){
        this.weight = weight;
        this.height = height;
    }

    //这里传入参数为Object类型
    public int compareTo(Object o){
        //这里要使用Cat类型进行转换时，需要将Object类型的参数转换为Cat类型
        Cat cat = (Cat)o;
        if (this.weight < cat.weight) return -1;
        else if(this.weight > cat.weight) return 1;
        else return 0;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Dog[] dogs = {new Dog(3), new Dog(5), new Dog(1)};
        Sorter sorter = new Sorter();
        sorter.sort(dogs);
        System.out.println(Arrays.toString(dogs));
    }
}

　　问五：如果比较对象与被比较对象类型不相同，那么传入参数进行强制转换时就会报错

　　　　答：利用java中泛型在演变三基础上进行修改

演变四：

　　在上一个版本基础上利用泛型进行代码修改

　　仅展示部分修改后代码，未修改的部分参照演变三中代码

//加上泛型，更加灵活
public interface Comparable<T> {
    //不必设置为Object类型
    public int compareTo(T o);
}

//实现接口时传入泛型
public class Dog implements Comparable<Dog> {

    int food;

    public Dog(int food){
        this.food = food;
    }

    //实现接口中方法，将传入参数确定比较类型
    @Override
    public int compareTo(Dog dog) {
        //增加泛型后这里减少了强制转换带来的隐患
        if (this.food<dog.food) return -1;
        else if (this.food<dog.food) return 1;
        else return 0;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "food=" + food +
                '}';
    }
}

演变五：

　　最完美的结果就是实现java中自带的comparable接口

二.comparator接口

　　接着上面comparable接口，在猫这个实体类在comparable接口中的比较策略是通过比较体重来进行判断的。但是，实际生活中比较猫可以通过很多方面，如体重、身高、身长等。那么怎样实现猫比较大小的策略可以灵活指定呢？

　　这里在解决上述问题时将原本的一个泛型变为两个泛型，第一个泛型为比较的数组，第二个泛型为打比较的策略。如果需要添加新的比较策略，只需在新建类中定义具体比较策略并实现相应接口，在需要调用时利用多态new出不同实现类即可实现不同方式的比较策略

public interface Comparator<T> {
    //定义两个泛型，第一个为比较数组，第二个为比较策略
    public int compare(T o1,T o2);
}

/**
 * 狗的比较器
 * 具体实现类，定义狗的具体比较策略
 */
public class DogComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog o1, Dog o2) {
        if (o1.food<o2.food) return -1;
        else if (o1.food>o2.food) return 1;
        else return 0;
    }
}

public class Sorter<T> {
    /**
     * 比较方法在调用时需要传入两个参数
     * 第一个参数为需要参与比较的数组，数组中存放n个狗的对象
     * 第二个参数为狗进行比较时的具体比较策略，这个根据具体需求利用多态new出来即可
     */
    public void sort(T[] arr,Comparator<T> comparator) {
        for (int i=0; i<arr.length - 1; i++){

            int minPoint = i;

            for(int j=i+1; j<arr.length; j++){
                minPoint = comparator.compare(arr[j], arr[minPoint] ) == -1 ? j : minPoint;
            }
            swap(arr, i, minPoint);
        }
    }

    void swap(T[] arr, int i , int j){
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

public class Dog {

    int food;

    public Dog(int food){
        this.food = food;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "food=" + food +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        Dog[] dogs = {new Dog(3), new Dog(5), new Dog(1)};
        Sorter sorter = new Sorter();
        sorter.sort(dogs,new DogComparator());
        System.out.println(Arrays.toString(dogs));
    }
}