JAVA中Arrays.sort()使用两种方式（Comparable和Comparator接口）对对象或者引用进行排序

来源：互联网发布：时雨改二数据编辑：程序博客网时间：2024/05/23 11:48

JAVA中Arrays.sort()使用两种方式（Comparable和Comparator接口）对对象或者引用进行排

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

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

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

数组的length是一个属性，而字符串的length()是一个方法了！！！虽然都是求的他们各自的长度( 与此题无关 )。

Sorting an Array ：

1. 数字排序 int[] intArray = new int[] { 4, 1, 3, -23 };

　　Arrays.sort(intArray);

　　输出： [-23, 1, 3, 4]

　　2. 字符串排序，先大写后小写 String[] strArray = new String[] { "z", "a", "C" };

　　Arrays.sort(strArray);

　　输出： [C, a, z]

　　3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　输出： [a, C, z]

　　4. 反向排序， Reverse-order sort

　　Arrays.sort(strArray, Collections.reverseOrder());

　　输出：[z, a, C]

　　5. 忽略大小写反向排序 Case-insensitive reverse-order sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　Collections.reverse(Arrays.asList(strArray));

　　输出： [z, C, a]

　　java初学者最常见的错误思想，就是试图去写一些方法来完成数组的排序功能，其实，数组排序功能，在java的api里面早已实现，我们没有必要去重复制造轮子。

二、源代码 (两种方式（Comparable和Comparator接口）对对象或者引用进行排序)

方式1：使用Comparable接口

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

运行结果：

comparable

方式2：使用Comparator接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
packagetong.day4_27.systemUse;
 
importjava.util.Arrays;
importjava.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
 *
 */
 
publicclass ComparatorUse {
 
     
    publicstatic void main(String[] args) {
        Student[] persons = newStudent[5];
        persons[0] =newStudent("tom",1,88,45);
        persons[1] =newStudent("jack",6,80,12);
        persons[2] =newStudent("bill",4,68,21);
        persons[3] =newStudent("kandy",2,98,34);
        persons[4] =newStudent("lily",5,94,20);
        System.out.println("排序前的数据：");
        for(Student student:persons) {
            System.out.println(student);
        }
        //创建SortByNumber对象，将其作为参数传入Arrays.sort(persons,sortByNumber)方法中
        SortByNumber sortByNumber = newSortByNumber();
        Arrays.sort(persons,sortByNumber);
        System.out.println("根据学生编号由低到高排序：");
        for(Student student:persons) {
            System.out.println(student);
        }
        SortByScore sortByScore = newSortByScore();
        Arrays.sort(persons,sortByScore);
        System.out.println("根据学生成绩由高到低排序：");
        for(Student student:persons) {
            System.out.println(student);
        }
 
 
    }
 
}
 
classStudent {
    privateString name;
    privateint number;
    privateint score;
    privateint age;
     
    publicStudent(String name,intnumber,intscore,intage){
        this.name = name;
        this.number = number;
        this.score = score;
        this.age = age;
    }
    //重写Student类的toString()方法，在输入对象时按照以下方式输出
    @Override
    publicString toString() {      
        return"Student[name:"+name+",age:"+age+",number:"+number+",score:"+score+"]";
    }
 
    publicString getName() {
        returnname;
    }
 
    publicvoid setName(String name) {
        this.name = name;
    }
 
    publicint getNumber() {
        returnnumber;
    }
 
    publicvoid setNumber(intnumber) {
        this.number = number;
    }
 
    publicint getScore() {
        returnscore;
    }
 
    publicvoid setScore(intscore) {
        this.score = score;
    }
 
    publicint getAge() {
        returnage;
    }
 
    publicvoid setAge(intage) {
        this.age = age;
    }
     
     
     
}
//按照学号由低到高排列,创建SortByNumber类，该类实现Comparator，重写该接口的compare()
classSortByNumber implementsComparator<student>{
    //重写该接口的compare()使其按照学号由小到大排序（前者减去后者）
    @Override
    publicint compare(Student o1, Student o2) {
        returno1.getNumber()-o2.getNumber();
         
    }
     
}
//按照分数由高到低排列，创建SortByScore类，该类实现Comparator，重写该接口的compare()
classSortByScore implementsComparator<student>{
    //重写该接口的compare()使其按照分数由高到低排序（后者减去前者）
    @Override
    publicint compare(Student o1, Student o2) {
        returno2.getScore()-o1.getScore();
         
    }
     
}</student></student></t>

运行结果：

加载中... vcg==" src="http://img.2cto.com/Collfiles/20150428/20150428084639195.png" />

阅读全文

0 0