Java复习笔记——Comparable 和 Comparator接口 引用类型比较

Comparable 接口

“排序”的实体类必须实现Comparable接口，Comparable接口中只有一个方法comparableTo（Object obj）

返回值:
- 0 表示两个对象相等
- 正数 this>obj
- 负数 this

int 类型比较（Integer）

return (i>o)?(i-o):((i==o)?0:(i-o));

char类型比较（Charactor）

return c1-c2 ；

字符串比较

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

首先获取两个字符串的长度，并获取长度短的String长度，遍历两个字符串，如果对应位置的字符不同，则返回两字符的差，如果两个字符串每个字符都相同，则返回两个字符串长度差

Comparable 案例

我们根据 猫的年龄给猫进行排序，猫就是我们的带排序实体类，所以需要实现Comparable接口

public class Cat implements Comparable<Cat> {
    public String name;
    public int age;

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

    public Cat() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    public int compareTo(Cat o) {
        // TODO Auto-generated method stub
        return this.age > o.age ? 1 : (this.age == o.age ? 0 : -1);
    }

    @Override
    public String toString() {
        return "Cat [name=" + name + ", age=" + age + "]";
    }


}

接下来我们创建测试类，进行测试

public class ComparaTest {

    public static void main(String[] args) {

        Cat[] cats = new Cat[] { new Cat("Tom", 2), new Cat("Jack", 5),
                new Cat("Tony", 3), };
        Arrays.sort(cats);
        System.out.println(Arrays.toString(cats));
    }

}

打印结果：
[Cat [name=Tom, age=2], Cat [name=Tony, age=3], Cat [name=Jack, age=5]]

如果我们想Cat按name排序，只需要在 compareTo(Cat o)方法中将排序规则改成上面的String 排序即可；

Comparator 接口

Comparator接口就比较强大了，我们每天逛淘宝、京东里面浏览商品的时候，可以选择，根据价格、销量、综合等排序，那我们怎么实现这样的功能呢？我们不可能使用Comparable接口来实现，因为我们很难在compareTo（）方法内动态选择，但是我们使用Comparator接口的化就可以轻松实现。因为Comparator接口实现了代码分离，我们的比较逻辑不用写在待排序实体类内，下面是Comparator接口的例子

创建Dog，Dog是我们的待排序实体类，但这里知识简单的Dog，不用实现任何接口

public class Dog {
    public String name;
    public int age;

    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Dog() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }
}

这里实现代码分离，单独写Comparator接口，这里我们依然以年龄来比较

public class DogComparatorByAge implements Comparator<Dog> {

    @Override
    public int compare(Dog o1, Dog o2) {

        return o1.age > o2.age ? 1 : (o1.age == o2.age ? 0 : -1);
    }

}

下面是我们的测试逻辑

public class ComparaTest {

    public static void main(String[] args) {

        Dog[] dogs = new Dog[] { new Dog("Tom", 2), new Dog("Jack", 5),
                new Dog("Tony", 3), };

        Arrays.sort(dogs, new DogComparatorByAge());

        System.out.println(Arrays.toString(dogs));
    }

测试结果：
[Dog [name=Tom, age=2], Dog [name=Tony, age=3], Dog [name=Jack, age=5]]

重点来了，我们如何进行动态改变排序规则，这里我们添加一个按name排序的规则

public class DogComparatorByName implements Comparator<Dog> {

    @Override
    public int compare(Dog o1, Dog o2) {

        int len1 = o1.name.toCharArray().length;
        int len2 = o2.name.toCharArray().length;
        int lim = Math.min(len1, len2);
        char v1[] = o1.name.toCharArray();
        char v2[] = o2.name.toCharArray();

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

}

我们的两个排序规则已经写好了，下面就是进行动态改变了。

public class ComparaTest {

    public static void main(String[] args) {

        Dog[] dogs = new Dog[] { new Dog("Tom", 2), new Dog("Jack", 5),
                new Dog("Tony", 3), };

        Arrays.sort(dogs, new DogComparatorByAge());

        System.out.println("通过Age排序"+Arrays.toString(dogs));

         Arrays.sort(dogs, new DogComparatorByName());

         System.out.println("通过Nme排序"+Arrays.toString(dogs));
    }

}

测试结果：

通过Age排序[Dog [name=Tom, age=2], Dog [name=Tony, age=3], Dog [name=Jack, age=5]]

通过Nme排序[Dog [name=Jack, age=5], Dog [name=Tom, age=2], Dog [name=Tony, age=3]]