JAVA中Arrays.sort()使用Comparable或Comparator接口对数组排序（转）

一、描述

自定义的类要按照一定的方式进行排序，比如一个Person类要按照年龄进行从小到大排序，比如一个Student类要按照成绩进行由高到低排序。

这里我们采用两种方式，一种是使用Comparable接口：让待排序对象所在的类实现Comparable接口，并重写Comparable接口中的compareTo()方法，缺点是只能按照一种规则排序。

另一种方式是使用Comparator接口：编写多个排序方式类实现Comparator接口，并重写新Comparator接口中的compare()方法，在调用Arrays的sort()时将排序类对象作为参数传入：public static <T> void sort(T[] a,Comparator<? super T> c),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的(也就是说，对于数组中的任何 e1 和 e2 元素而言，c.compare(e1, e2) 不得抛出 ClassCastException)。

优点是可以按照多种方式排序，你要按照什么方式排序，就创建一个实现Comparator接口的排序方式类，然后将该排序类的对象传入到Arrays.sort(待排序对象，该排序方式类的对象)

二、源代码

方式1：使用Comparable接口

[java] view plain copy

print ?

1. package tong.day4_27.systemUse;  
2.   
3. import java.util.Arrays;  
4. /** 
5.  * 使用Comparable接口：让待排序对象所在的类实现Comparable接口，并重写Comparable接口中的compareTo()方法 
6.  * 缺点是只能按照一种规则排序 
7.  * @author tong 
8.  * 
9.  */  
10. public class ObjectSort {  
11.   
12.     public static void main(String[] args) {  
13.         Person[] persons = new Person[5];  
14.         persons[0] =new Person(“tom”,45);  
15.         persons[1] =new Person(“jack”,12);  
16.         persons[2] =new Person(“bill”,21);  
17.         persons[3] =new Person(“kandy”,34);  
18.         persons[4] =new Person();  
19.         Arrays.sort(persons);  
20.         for (Person person:persons) {  
21.             System.out.println(person);  
22.         }  
23.   
24.     }  
25.   
26. }  
27. class Person implements Comparable<Person>{  
28.     private String name;  
29.     private int age;  
30.       
31.     public Person(String name,int age){  
32.         this.name = name;  
33.         this.age = age;  
34.     }  
35.     public Person(){  
36.         this(“unknown”, 0);  
37.     }  
38.     //重写该类的compareTo()方法，使其按照从小到大顺序排序  
39.     @Override  
40.     public int compareTo(Person o) {  
41.          return age-o.age;  
42.           
43.     }  
44.     //重写Student类的toString()方法，在输入对象时按照以下方式输出  
45.     @Override  
46.     public String toString() {        
47.         return “Person[name:”+name+“,age:”+age+“]”;  
48.     }  
49.       
50. }  

package tong.day4_27.systemUse;

import java.util.Arrays;
/**
 * 使用Comparable接口：让待排序对象所在的类实现Comparable接口，并重写Comparable接口中的compareTo()方法
 * 缺点是只能按照一种规则排序
 * @author tong
 *
 */
public class ObjectSort {

    public static void main(String[] args) {
        Person[] persons = new Person[5];
        persons[0] =new Person("tom",45);
        persons[1] =new Person("jack",12);
        persons[2] =new Person("bill",21);
        persons[3] =new Person("kandy",34);
        persons[4] =new Person();
        Arrays.sort(persons);
        for (Person person:persons) {
            System.out.println(person);
        }

    }

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

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(){
        this("unknown", 0);
    }
    //重写该类的compareTo()方法，使其按照从小到大顺序排序
    @Override
    public int compareTo(Person o) {
         return age-o.age;

    }
    //重写Student类的toString()方法，在输入对象时按照以下方式输出
    @Override
    public String toString() {      
        return "Person[name:"+name+",age:"+age+"]";
    }

}

运行结果：

方式2：使用Comparator接口

[java] view plain copy

print ?

1. package tong.day4_27.systemUse;  
2.   
3. import java.util.Arrays;  
4. import java.util.Comparator;  
5.   
6. /** 
7.  * 使用Comparator接口：编写多个排序方式类实现Comparator接口，并重写新Comparator接口中的compare()方法 
8.  * public static <T> void sort(T[] a,Comparator<? super T> c),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的 
9.  * （也就是说，对于数组中的任何 e1 和 e2 元素而言，c.compare(e1, e2) 不得抛出 ClassCastException）。 
10.  * 优点是可以按照多种方式排序，你要按照什么方式排序，就创建一个实现Comparator接口的排序方式类，然后将该排序类的对象传入到Arrays.sort(待排序对象，该排序方式类的对象) 
11.  * @author tong 
12.  * 
13.  */  
14.   
15. public class ComparatorUse {  
16.   
17.       
18.     public static void main(String[] args) {  
19.         Student[] persons = new Student[5];  
20.         persons[0] =new Student(“tom”,1,88,45);  
21.         persons[1] =new Student(“jack”,6,80,12);  
22.         persons[2] =new Student(“bill”,4,68,21);  
23.         persons[3] =new Student(“kandy”,2,98,34);  
24.         persons[4] =new Student(“lily”,5,94,20);  
25.         System.out.println(”排序前的数据：”);  
26.         for (Student student:persons) {  
27.             System.out.println(student);  
28.         }  
29.         //创建SortByNumber对象，将其作为参数传入Arrays.sort(persons,sortByNumber)方法中  
30.         SortByNumber sortByNumber = new SortByNumber();  
31.         Arrays.sort(persons,sortByNumber);  
32.         System.out.println(”根据学生编号由低到高排序：”);  
33.         for (Student student:persons) {  
34.             System.out.println(student);  
35.         }  
36.         SortByScore sortByScore = new SortByScore();  
37.         Arrays.sort(persons,sortByScore);  
38.         System.out.println(”根据学生成绩由高到低排序：”);  
39.         for (Student student:persons) {  
40.             System.out.println(student);  
41.         }  
42.   
43.   
44.     }  
45.   
46. }  
47.   
48. class Student {  
49.     private String name;  
50.     private int number;  
51.     private int score;  
52.     private int age;  
53.       
54.     public Student(String name,int number,int score,int age){  
55.         this.name = name;  
56.         this.number = number;  
57.         this.score = score;  
58.         this.age = age;  
59.     }  
60.     //重写Student类的toString()方法，在输入对象时按照以下方式输出  
61.     @Override  
62.     public String toString() {        
63.         return “Student[name:”+name+“,age:”+age+“,number:”+number+“,score:”+score+“]”;  
64.     }  
65.   
66.     public String getName() {  
67.         return name;  
68.     }  
69.   
70.     public void setName(String name) {  
71.         this.name = name;  
72.     }  
73.   
74.     public int getNumber() {  
75.         return number;  
76.     }  
77.   
78.     public void setNumber(int number) {  
79.         this.number = number;  
80.     }  
81.   
82.     public int getScore() {  
83.         return score;  
84.     }  
85.   
86.     public void setScore(int score) {  
87.         this.score = score;  
88.     }  
89.   
90.     public int getAge() {  
91.         return age;  
92.     }  
93.   
94.     public void setAge(int age) {  
95.         this.age = age;  
96.     }  
97.       
98.       
99.       
100. }  
101. //按照学号由低到高排列,创建SortByNumber类，该类实现Comparator，重写该接口的compare()  
102. class SortByNumber implements Comparator<Student>{  
103.     //重写该接口的compare()使其按照学号由小到大排序（前者减去后者）  
104.     @Override  
105.     public int compare(Student o1, Student o2) {  
106.         return o1.getNumber()-o2.getNumber();  
107.           
108.     }  
109.       
110. }  
111. //按照分数由高到低排列，创建SortByScore类，该类实现Comparator，重写该接口的compare()  
112. class SortByScore implements Comparator<Student>{  
113.     //重写该接口的compare()使其按照分数由高到低排序（后者减去前者）  
114.     @Override  
115.     public int compare(Student o1, Student o2) {  
116.         return o2.getScore()-o1.getScore();  
117.           
118.     }  
119.       
120. }  

package tong.day4_27.systemUse;

import java.util.Arrays;
import java.util.Comparator;

/**
 * 使用Comparator接口：编写多个排序方式类实现Comparator接口，并重写新Comparator接口中的compare()方法
 * public static <T> void sort(T[] a,Comparator<? super T> c),根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器可相互比较的
 * （也就是说，对于数组中的任何 e1 和 e2 元素而言，c.compare(e1, e2) 不得抛出 ClassCastException）。
 * 优点是可以按照多种方式排序，你要按照什么方式排序，就创建一个实现Comparator接口的排序方式类，然后将该排序类的对象传入到Arrays.sort(待排序对象，该排序方式类的对象)
 * @author tong
 *
 */

public class ComparatorUse {


    public static void main(String[] args) {
        Student[] persons = new Student[5];
        persons[0] =new Student("tom",1,88,45);
        persons[1] =new Student("jack",6,80,12);
        persons[2] =new Student("bill",4,68,21);
        persons[3] =new Student("kandy",2,98,34);
        persons[4] =new Student("lily",5,94,20);
        System.out.println("排序前的数据：");
        for (Student student:persons) {
            System.out.println(student);
        }
        //创建SortByNumber对象，将其作为参数传入Arrays.sort(persons,sortByNumber)方法中
        SortByNumber sortByNumber = new SortByNumber();
        Arrays.sort(persons,sortByNumber);
        System.out.println("根据学生编号由低到高排序：");
        for (Student student:persons) {
            System.out.println(student);
        }
        SortByScore sortByScore = new SortByScore();
        Arrays.sort(persons,sortByScore);
        System.out.println("根据学生成绩由高到低排序：");
        for (Student student:persons) {
            System.out.println(student);
        }


    }

}

class Student {
    private String name;
    private int number;
    private int score;
    private int age;

    public Student(String name,int number,int score,int age){
        this.name = name;
        this.number = number;
        this.score = score;
        this.age = age;
    }
    //重写Student类的toString()方法，在输入对象时按照以下方式输出
    @Override
    public String toString() {      
        return "Student[name:"+name+",age:"+age+",number:"+number+",score:"+score+"]";
    }

    public String getName() {
        return name;
    }

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

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getAge() {
        return age;
    }

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



}
//按照学号由低到高排列,创建SortByNumber类，该类实现Comparator，重写该接口的compare()
class SortByNumber implements Comparator<Student>{
    //重写该接口的compare()使其按照学号由小到大排序（前者减去后者）
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getNumber()-o2.getNumber();

    }

}
//按照分数由高到低排列，创建SortByScore类，该类实现Comparator，重写该接口的compare()
class SortByScore implements Comparator<Student>{
    //重写该接口的compare()使其按照分数由高到低排序（后者减去前者）
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getScore()-o1.getScore();

    }

}

运行结果：