Java對象比較-Comparable和Comparator接口使用

最近在學習貪心算法和動態規划的過程中，里面有一段自然排序的操作，順便簡單了解一下Java中對象比較后排序要使用的兩個接口：Comparable和Comparator。如果是數字，直接比較就行，但是如果是對象，如何比較后排序呢？就需要用到這兩個接口了，並且將自己定義的類作為參數傳入接口泛型，在接口里重寫比較方法，將自己要選擇排序的類屬性添加到比較條件中去。

接口主要區別

（1）Comparable接口是在java.lang下，Comparator接口是在java.util下。

（2）如果在定義類時，就實現了Comparable接口，直接在里面重寫compareTo()方法，如果沒實現，后面在業務開發中需要有比較排序的功能，就再單獨寫一個類實現Comparator接口，在里面重寫compare()方法，然后這個類需要作為參數傳入到工具類Collections.sort和Arrays.sort方法中。

（3）實現Comparable接口的類必須是自然排序，另外一個不是強制條件。

使用Comparable

（1）定義實現類時，實現Comparable接口。

/**
 * 實體類，實現Comparable接口
 */
public class Person implements Comparable<Person>{

    //屬性
    private String name;
    private int age;
    private int salary;

    //get和set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    //構造方法
    public Person(String name, int age, int salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

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

    //重寫接口方法,o為要比較的對象
    @Override
    public int compareTo(Person o) {
        //大於要比較的對象就返回1
        if(this.salary>o.getSalary()){
            return 1;
        }
        //小於則返回-1
        else if(this.salary<o.getSalary()){
            return -1;
        }
        //相等則返回0
        return 0;
    }
}

（2）測試類，來查看是否按照自定義的屬性進行自然排序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestComparable {

    public static void main(String[] args) {
        //測試Comparable接口
        Person p1=new Person("clyang",18,4000);
        Person p2=new Person("messi",30,8000);
        Person p3=new Person("ronald",32,9000);
        Person p4=new Person("herry",19,7600);
        Person p5=new Person("roben",35,7900);

        //添加到集合
        List<Person> list=new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);

        System.out.println("-----------------排序前-----------------");
        for (Person person : list) {
            System.out.println(person);
        }

        //排序一般使用Collections.sort方法，或者使用Arrays.sort方法，按照比較的元素進行自然排序，即從小到大
        Collections.sort(list);

        System.out.println("-----------------排序后-----------------");
        for (Person person : list) {
            System.out.println(person);
        }

    }
}

控制台輸出情況，發現正常的按照工資進行了自然排序，即升序排列。

使用Comparator

使用這個接口時，創建類的時候可以不實現接口，需要單獨創建一個類來實現這個接口。

（1）創建類

/**
 * 實體類，不實現Comparable接口，使用單獨的Comparator接口
 */
public class Staff {

    //屬性
    private String name;
    private int age;
    private int salary;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

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

（2）創建實現接口的類，重寫里面的比較方法，這屬於泛型在接口中的一種使用方法，即接口泛型是什么，實現類里面就是什么泛型。

import java.util.Comparator;

/**
 * 單獨寫的比較器，實現Compartor接口
 */
public class StaffComparator implements Comparator<Staff> {

    //不一定要自然排序即升序，可以反過來寫成降序
    @Override
    public int compare(Staff o1, Staff o2) {
        //降序
        /*if(o1.getSalary()>o2.getSalary()){
            return -1;
        }
        if(o1.getSalary()<o2.getSalary()){
            return 1;
        }
        return 0;*/

        //升序
        /*if(o1.getSalary()>o2.getSalary()){
            return 1;
        }
        if(o1.getSalary()<o2.getSalary()){
            return -1;
        }
        return 0;*/

        //先按照年齡倒序排，如果年齡相等比較工資
        if(o1.getAge()>o2.getAge()){
            return -1;
        }
        if(o1.getAge()<o2.getAge()){
            return 1;
        }
        //能到這里說明年齡相等，繼續比較工資
        if(o1.getSalary()>o2.getSalary()){
            return 1;
        }
        if(o1.getSalary()<o2.getSalary()){
            return -1;
        }
        return 0;
    }
}

測試類，來查看是否按照自己的要求來排序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class TestComparator {

    public static void main(String[] args) {
        //測試Comparator接口
        Staff p1=new Staff("clyang",18,4000);
        Staff p2=new Staff("messi",30,8000);
        Staff p3=new Staff("ronald",32,9000);
        Staff p4=new Staff("herry",18,7600);
        Staff p5=new Staff("roben",35,7900);

        //添加到集合
        List<Staff> list=new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);

        System.out.println("-----------------排序前-----------------");
        for (Staff staff : list) {
            System.out.println(staff);
        }

        //排序，需要使用自定義比較類
        Comparator myComparator=new StaffComparator();
        Collections.sort(list,myComparator);

        System.out.println("-----------------排序后-----------------");
        for (Staff staff : list) {
            System.out.println(staff);
        }
    }
}

控制台輸出情況，可以發現，先是按照年齡進行了倒排序，當排到clyang和herry的時候，由於年齡相同，因此繼續按照工資來升排序。

以上是兩種接口的使用方法，也是參考了博主的文章學習的，以后可以拿來用。

參考博文：

（1）https://www.cnblogs.com/Kevin-mao/p/5912775.html

（2）https://www.cnblogs.com/youngchaolin/p/11029505.html