Java Comparator 接口及实例

比较器接口用于对用户定义的类的对象进行排序。一个比较器对象能够比较同一类别的两个对象。以下是比较obj1和obj2的函数。

语法

public int compare(Object obj1, Object obj2):

假设我们有一个我们自己的类的数组/阵列列表，包含像roll no, name, address, DOB等字段，我们需要根据roll no或name对数组进行排序？

方法1 ：一个明显的方法是使用一个标准算法编写我们自己的sort()函数。这种方法需要为不同的标准（如卷号和姓名）重写整个排序代码。

方法2： 使用比较器接口–比较器接口用于对用户定义的类的对象进行排序。这个接口存在于java.util包中，包含2个方法compare(Object obj1, Object obj2) 和 equals(Object element)。使用比较器，我们可以根据数据成员对元素进行排序。例如，它可能是根据卷号、姓名、年龄或其他任何东西。

Collections类的方法用于对List元素进行排序，通过给定的比较器对List的元素进行排序。

public void sort(List list, ComparatorClass c)

要对一个给定的列表进行排序，比较器类必须实现一个比较器接口。

集合类的sort()方法是如何工作的

在内部，排序方法会调用它所排序的类的比较方法。为了比较两个元素，它会问 “哪个更大？”比较方法返回-1、0或1，说明它是小于、等于还是大于另一个。它使用这个结果来决定它们是否应该被交换来进行排序。

例子

// Java Program to Demonstrate Working of
// Comparator Interface
 
// Importing required classes
import java.io.*;
import java.lang.*;
import java.util.*;
 
// Class 1
// A class to represent a Student
class Student {
 
    // Attributes of a student
    int rollno;
    String name, address;
 
    // Constructor
    public Student(int rollno, String name, String address)
    {
 
        // This keyword refers to current instance itself
        this.rollno = rollno;
        this.name = name;
        this.address = address;
    }
 
    // Method of Student class
    // To print student details in main()
    public String toString()
    {
 
        // Returning attributes of Student
        return this.rollno + " " + this.name + " "
            + this.address;
    }
}
 
// Class 2
// Helper class implementing Comparator interface
class Sortbyroll implements Comparator<Student> {
 
    // Method
    // Sorting in ascending order of roll number
    public int compare(Student a, Student b)
    {
 
        return a.rollno - b.rollno;
    }
}
 
// Class 3
// Helper class implementing Comparator interface
class Sortbyname implements Comparator<Student> {
 
    // Method
    // Sorting in ascending order of name
    public int compare(Student a, Student b)
    {
 
        return a.name.compareTo(b.name);
    }
}
 
// Class 4
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an empty ArrayList of Student type
        ArrayList<Student> ar = new ArrayList<Student>();
 
        // Adding entries in above List
        // using add() method
        ar.add(new Student(111, "Mayank", "london"));
        ar.add(new Student(131, "Anshul", "nyc"));
        ar.add(new Student(121, "Solanki", "jaipur"));
        ar.add(new Student(101, "Aggarwal", "Hongkong"));
 
        // Display message on console for better readability
        System.out.println("Unsorted");
 
        // Iterating over entries to print them
        for (int i = 0; i < ar.size(); i++)
            System.out.println(ar.get(i));
 
        // Sorting student entries by roll number
        Collections.sort(ar, new Sortbyroll());
 
        // Display message on console for better readability
        System.out.println("\nSorted by rollno");
 
        // Again iterating over entries to print them
        for (int i = 0; i < ar.size(); i++)
            System.out.println(ar.get(i));
 
        // Sorting student entries by name
        Collections.sort(ar, new Sortbyname());
 
        // Display message on console for better readability
        System.out.println("\nSorted by name");
 
        // // Again iterating over entries to print them
        for (int i = 0; i < ar.size(); i++)
            System.out.println(ar.get(i));
    }
}

输出

Unsorted
111 Mayank london
131 Anshul nyc
121 Solanki jaipur
101 Aggarwal Hongkong

Sorted by rollno
101 Aggarwal Hongkong
111 Mayank london
121 Solanki jaipur
131 Anshul nyc

Sorted by name
101 Aggarwal Hongkong
131 Anshul nyc
111 Mayank london
121 Solanki jaipur

通过改变比较方法里面的返回值，你可以按照你希望的任何顺序进行排序，例如。对于降序，只需改变上述比较方法中’a’和’b’的位置。

按一个以上的字段对集合进行排序

在前面的例子中，我们已经讨论了如何使用Comparable和Comparator接口根据单个字段对对象列表进行排序，但是，如果我们需要根据多个字段对ArrayList对象进行排序，例如，首先根据学生姓名进行排序，其次根据学生年龄进行排序，该怎么办？

例子

// Java Program to Demonstrate Working of
// Comparator Interface Via More than One Field
 
// Importing required classes
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
 
// Class 1
// Helper class representing a Student
class Student {
 
    // Attributes of student
    String Name;
    int Age;
 
    // Parameterized constructor
    public Student(String Name, Integer Age)
    {
 
        // This keyword refers to current instance itself
        this.Name = Name;
        this.Age = Age;
    }
 
    // Getter setter methods
    public String getName() { return Name; }
 
    public void setName(String Name) { this.Name = Name; }
 
    public Integer getAge() { return Age; }
 
    public void setAge(Integer Age) { this.Age = Age; }
 
    // Method
    // Overriding toString() method
    @Override public String toString()
    {
        return "Customer{"
            + "Name=" + Name + ", Age=" + Age + '}';
    }
 
    // Class 2
    // Helper class implementing Comparator interface
    static class CustomerSortingComparator
        implements Comparator<Student> {
 
        // Method 1
        // To compare customers
        @Override
        public int compare(Student customer1,
                           Student customer2)
        {
 
            // Comparing customers
            int NameCompare = customer1.getName().compareTo(
                customer2.getName());
 
            int AgeCompare = customer1.getAge().compareTo(
                customer2.getAge());
 
            // 2nd level comparison
            return (NameCompare == 0) ? AgeCompare
                                      : NameCompare;
        }
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Create an empty ArrayList
        // to store Student
        List<Student> al = new ArrayList<>();
 
        // Create customer objects
        // using constructor initialization
        Student obj1 = new Student("Ajay", 27);
        Student obj2 = new Student("Sneha", 23);
        Student obj3 = new Student("Simran", 37);
        Student obj4 = new Student("Ajay", 22);
        Student obj5 = new Student("Ajay", 29);
        Student obj6 = new Student("Sneha", 22);
 
        // Adding customer objects to ArrayList
        // using add() method
        al.add(obj1);
        al.add(obj2);
        al.add(obj3);
        al.add(obj4);
        al.add(obj5);
        al.add(obj6);
 
        // Iterating using Iterator
        // before Sorting ArrayList
        Iterator<Student> custIterator = al.iterator();
 
        // Display message
        System.out.println("Before Sorting:\n");
 
        // Holds true till there is single element
        // remaining in List
        while (custIterator.hasNext()) {
 
            // Iterating using next() method
            System.out.println(custIterator.next());
        }
 
        // Sorting using sort method of Collections class
        Collections.sort(al,
                         new CustomerSortingComparator());
 
        // Display message only
        System.out.println("\n\nAfter Sorting:\n");
 
        // Iterating using enhanced for-loop
        // after Sorting ArrayList
        for (Student customer : al) {
            System.out.println(customer);
        }
    }
}

输出

Before Sorting:

Customer{Name=Ajay, Age=27}
Customer{Name=Sneha, Age=23}
Customer{Name=Simran, Age=37}
Customer{Name=Ajay, Age=22}
Customer{Name=Ajay, Age=29}
Customer{Name=Sneha, Age=22}


After Sorting:

Customer{Name=Ajay, Age=22}
Customer{Name=Ajay, Age=27}
Customer{Name=Ajay, Age=29}
Customer{Name=Simran, Age=37}
Customer{Name=Sneha, Age=22}
Customer{Name=Sneha, Age=23}