java中Comparable和Comparator

目录

1.Comparable

2.Comparator

3.Comparable和Comparator的区别

 

Comparable

1. Comparable是java.lang包中的一个排序接口。

2. 只要一个类实现了这个接口就可以意味着这个类支持排序。

3.实现了这个类的接口的列表或者数组可以可以使用Collections.sort或Arrays.sort进行排序。

4.该接口的定义：

public interface Comparable<T> 
{
    public int compareTo(T o);
}

T表示可以与这个对象进行比较的那些对象的类型。

这个类只有一个compareTo方法。实现这个接口的类必须要重写这个方法。

比较的规则：

• 如果该对象和指定比较的对象相等，那么返回0。
• 如果该对象比指定比较的对象大，那么返回正数。
• 如果该对象比指定比较的对象小，返回负数。

实例：

实现Comparable的类：

class Person implements Comparable<Person>{
    String name;
    int age;

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

    /**
     * 重新的compareTo方法。
     * @param person 用于指定的比较的对象。
     * @returns 如果当前对象的年龄和指定对象的年龄相等则返回0，如果当前对象的年龄大于指定对象
     * 的年龄则返回正数。如果当前对象的年龄比指定对象的年龄小，则返回负数。
     */
    @Override
    public int compareTo(Person person) {
        return this.age - person.age;
    }
}

note：这里为了演示，没有进行封装。

进行比较演示：

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        // 创建一个Person数组。
        Person[] persons = new Person[]{new Person("tom", 20), new Person("jack", 12)};

        // 排序之前
        System.out.print("排序之前：");
        for (Person p : persons) {
            System.out.print("name:" + p.name + ", age:" + p.age + " ");
        }
        
        // 排序之后
        Arrays.sort(persons);
        System.out.println("排序之后:");
        for (Person p : persons) {
            System.out.print("name:" + p.name + ", age:" + p.age + " ");
        }

    }
}

结果：

 

如何判断是正序排序还是倒序排序

---

相信不少人都有疑惑，类似于this.age-person.age和person.age-this.age的区别是什么？怎么样写是正序还是倒序。

我们上面已经说过了，程序根据compareTo方法的返回值来判断两个值的大小问题。从而决定了两个数的顺序问题。具体是怎么决定的呢？

我们假设两个数一个数是a, b。程序如何决定两个数的顺序呢？

1)如果我们代码写的a-b，那么程序会这么思考：

• a-b < 0。说明a小于b，所以两者的顺序是:a, b。
• a-b > 0。说明a大于b，所以两者的顺序是:b, a。
• a-b=0。说明a等于b，所以两个数的顺序是:a, b

2)如果我们代码写的是b-a，那么程序会这么思考：

• b-a<0，程序就会认为a < b(实际上a > b)，所以两者的顺序为:a, b。
• b-a>0，程序就会认为a > b(实际上a < b)，所以两者的顺序为:b, a。
• b-a=0，程序就会认为a=b(实际上a=b)，所以两者的顺序为a,b。

从上面我们看到当我们写b-a的时候，实际上程序把a当成了b，把b当成了a。所以，才会出现相反的结果。

由此可见，我们写a-b的时候是正序。我们写b-a的时候是倒序。

Comparator

---

1.Comparator是java.util中的一个比较的接口。

2. 如果我们想要控制某个类的次序，而这个类并没有继承Comparable接口，那么我们就可以使用Comparator接口。

3. 比较的规则：大致和上面的规则相同，不过也有不同的地方，详情请看下面的代码。

4.源代码：

package java.util;
public interface Comparator<T>
 {
    int compare(T o1, T o2);
    boolean equals(Object obj);
 }

使用步骤

1. 首先创意一个类实现Comparatro接口。note：这个类为你要比较的类的比较类。eg:如果你要想要比较Person对象，那么不要让Person实现这个接口，而是创建一个新的类叫做：PersonComparator，使用这个类实现Comparator。
2. 比较时，传递比较器即可。

实例：

要比较的类

class Person {
    String name;
    int age;

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

该类的比较类

class PersonComparator implements Comparator<Person> {
    /**
     * 用来比较两个对象的年龄。
     * @param p1 用来比较的第一个对象。
     * @param p2 用力比较的第二个对象。
     * @return 如果两个对象相等，则返回零。如果第一个对象大于第二个对象，则返回正数。如果第二个对象大于第一个对象，则返回负数。
     */
    @Override
    public int compare(Person p1, Person p2) {
        return p1.age - p2.age;
    }
}

比较演示：

import java.util.Comparator;
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        // 创建一个Person数组。
        Person[] persons = new Person[]{new Person("tom", 20), new Person("jack", 12)};

        // 排序之前
        System.out.print("排序之前：");
        for (Person p : persons) {
            System.out.print("name:" + p.name + ", age:" + p.age + " ");
        }
        
        // 排序之后
        // 将比较器作为参数传入。
        Arrays.sort(persons, new PersonComparator());
        System.out.println("排序之后:");
        for (Person p : persons) {
            System.out.print("name:" + p.name + ", age:" + p.age + " ");
        }
    }
}

也可以使用匿名数组：

import java.util.Comparator;
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        // 创建一个Person数组。
        Person[] persons = new Person[]{new Person("tom", 20), new Person("jack", 12)};

        // 排序之前
        System.out.print("排序之前：");
        for (Person p : persons) {
            System.out.print("name:" + p.name + ", age:" + p.age + " ");
        }
        
        // 排序之后
        // 将比较器作为参数传入。
        Arrays.sort(persons, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.age - p2.age;
            }
        });
        System.out.println("排序之后:");
        for (Person p : persons) {
            System.out.print("name:" + p.name + ", age:" + p.age + " ");
        }

    }
}

效果：

 

 

Comparable和Comparator的区别：

1.两者不在一个包。Comparable在java.lang中，而Comparator在java.util包中。

2.实现Comparable的类通常是一个我们要经常使用的类。比如：java中的String类等等。需要修改源代码。而Comparator可以在不同修改源代码的情况下，来完成比较。从了保护了代码。

两个方法各有优劣。如果你的类需要经常使用比较的操作，那么可以考虑让这个了实现Comparable接口。如果你偶尔使用比较的操作，那么可以考虑使用Comparator。

 

 

注意：作者是一个自学编程的初学者，如果文章有任何错误的地方，望各位编程大佬进行指正，谢谢。