Java中的Comparable接口、Comparator接口与CompareTo方法

Java集合中的Comparable接口和Comparator接口的区别

---

Comparable接口

• Comparable简介

Comparable接口位于java.lang.Comparable，如果一个类实现了Comparable接口，就说明这个类是支持排序的，那在实现Comparable接口的类的对象的List就可以通过调用Collections.sort或Arrays.sort进行排序。

• Comparable接口的定义

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

• 测试演示

1.定义一个员工Employee类：

public class Employee {
    private String name;
    private int age;
    private double salary;

// getter和setter方法省略了 自己测试的话需要带上

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public Employee() {
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

2.定义 EmployeeComparable类，继承Employee ， 实现 Comparable接口，重写CompareTo方法。

public class EmployeeComparable extends Employee implements Comparable<Employee> {
    @Override
    public int compareTo(Employee o) {
        //需求： age年龄从小到大排列， salary工资从大到小排
        if (this.getAge() - o.getAge() == 0) {
            return (int) (o.getSalary() - this.getSalary());
        } else {
            return this.getAge() - o.getAge();
        }
    }

    public EmployeeComparable(String name, int age, double score) {
        super(name, age, score);
    }
}

3.写测试类，测试排序功能

public class EmployeeComparableTest {
    @Test
    public void test() {
        EmployeeComparable s1 = new EmployeeComparable("张三", 18, 3000);
        EmployeeComparable s2 = new EmployeeComparable("李四", 15, 2000);
        EmployeeComparable s3 = new EmployeeComparable("王五", 25, 5055);
        EmployeeComparable s4 = new EmployeeComparable("赵六", 25, 6066);

        List list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        // 排序前
        System.out.println(list);

        //调用sort方法
        Collections.sort(list);

        // 排序后
        System.out.println(list);
    }
}

4.测试结果

根据排序前后的输出，可以看到年龄是从小到大的，而工资是从大到小的，达到了预期的排序效果.

在应用中为了更好的判断，一般的写法是：

if (this.getAge()<o.getAge()){
            return -1;
        }else if(this.getAge()>o.getAge()){
            return 1;
        }else{
            return 0;
        }

---

Comparator接口

• Comparator简介

Comparator接口位于java.util.Comparator,Comparator 是比较器接口,当我们需要控制某个类的次序，而这个类是不支持排序的(没有实现comparable接口),那我们用比较器来进行排序，这个比较器需要实现comparator接口，简而言之就是通过实现Comparator接口来建立一个比较器，从而通过比较器来对这个类进行排序.

• Comparator接口定义

package java.util;

public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);
}`

如果要实现Comparator接口，一定要实现compare(T o1, T o2)函数，但是可以不实现equals(Object obj)函数。
因为任何类，默认都是已经实现了equals(Object obj)的。 Java中的一切类都是继承于java.lang.Object，在Object.java中实现了equals(Object obj)函数，所以所有类相当于都是实现了`equals(Object obj)函数的。

int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，说明“o1<o2”；返回“零”，意味着“o1等于o2”；返回“正数”，说明“o1>o2”.

• 测试演示
  1.定义 EmployeeComparator类，继承Employee ， 实现 Comparator接口，重写compare方法。

public class EmployeeComparator extends Employee implements Comparator<Employee> {
    @Override
    //年龄采用升序 年龄相同工资采用降序
    public int compare(Employee o1, Employee o2) {
        if (o1.getAge() == o2.getAge()) {
            return (int) (o2.getSalary() - o1.getSalary());
        } else {
            return o1.getAge() - o2.getAge();
        }
    }

    public EmployeeComparator() {
        super();
    }

    public EmployeeComparator(String name, int age, double salary) {
        super(name, age, salary);
    }
}

2.写测试类，测试排序功能

public class EmployeeComparatorTest {
    @Test
    public void test() {
        EmployeeComparator s1 = new EmployeeComparator("张三", 18, 3000);
        EmployeeComparator s2 = new EmployeeComparator("李四", 15, 2000);
        EmployeeComparator s3 = new EmployeeComparator("王五", 25, 5055);
        EmployeeComparator s4 = new EmployeeComparator("赵六", 25, 6066);

        List list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        // 排序前
        System.out.println(list);

        //调用sort方法
        Collections.sort(list, new EmployeeComparator());

        // 排序后
        System.out.println(list);
    }
}

3.测试结果

根据排序前后的输出，可以看到年龄是从小到大的，而工资是从大到小的，达到了预期的排序效果.

---

总结Comparable与comparator

1. Comparable 位于 java.lang 包， Comparator 位于java.util 包。
2. 实现Comparable接口需要重写compareTo()方法，实现Comparator方法需要重写compare()方法，这两个方法的类型都是int
3. Comparable是排序接口，相当于内部比较器，称为自然排序，Comparator是比较器，相当于外部比较器，称为比较器排序，外部比较器可以对内部比较器进行扩充。
4. int test = s1.compareTo(s2); result = 0 , 则 s1=s2 ; result < 0, 则 s1 0 , 则 s1 > s2 。int test= compare(T o1, T o2); 结果同上。 （若是 o2-o1，则反之。）
5. 总而言之，如果对象的排序需要基于自然顺序，使用 Comparable比较合适，如果需要按照对象的不同属性进行排序，使用 Comparator比较合适。

---

拓展Java中的compareTo方法

• 返回参与比较的前后两个字符串的asc码的差值，如果两个字符串首字母不同，则该方法返回首字母的asc码的差值

		//ASCII表中A是65 D是68
		String s1 = "A";
        String s2 = "D";        
        System.out.println(s1.compareTo(s2));
        //结果为-3

• 如果首字符相同比较下一个字符，直到有不同的为止，同样返回asc码的差值

		String s1 = "AAAAA";
        String s2 = "AAAAD";        
        System.out.println(s1.compareTo(s2));
        //结果为-3

• 如果两个字符不同，但是前面参照比较的相同，就返回两个字符串的长度差值

		String s1 = "AA";
        String s2 = "AA123456789";        
        System.out.println(a1.compareTo(a2));
        //结果为-9

返回正数说明s1>s2,返回负数说明s1<s2.

• 数字类型不能用compareTo,直接用’>’ ‘<’ '='等等(但也可以通过转换成String类型来使用)，但封装数据类型可以，Date、String、Integer、或者其他的，可以直接使用compareTo()

		Integer s1 = 6;
        Integer s2 = 8;
        System.out.println(n1.compareTo(n2));
        //结果为-2