Java中的排序

发表于 | 分类于

Java中的排序

这里介绍两种常用的排序对象：对数组的排序和对list的排序。

数组的排序

数组的排序主要采用Arrays.sort()方法，默认为升序。常用API有：

1
2
3
4
5
6
7
8
9
10
Arrays.sort(array_name,startindex,endindex);

Arrays.sort(array_name);

Arrays.sort(a3, new Comparator<people>() {
	@Override
    public int compare(people o1, people o2) {
            return Integer.compare(o1.age, o2.age);
    }
});

若想降序，可以先将数组转换为list：

1
2
List tmp = Arrays.asList(a1);
Collections.sort(tmp, Collections.reverseOrder());

List的排序

List排序主要采用Comparator类中的sort方法，主要API有：

1
2
3
4
5
6
7
8
Collections.sort(Listname);
Collections.sort(Listname, Collections.reverseOrder());
Collections.sort(l1, new Comparator<people>() {
   @Override
   public int compare(people o1, people o2) {
          return Integer.compare(o1.age, o2.age);
   }
});

可以看出两者的自定义排序均为重写compare方法。

总体体的代码如下所示：

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
import java.util.*;

class people {
    int age;
    String name;

    people(int age, String name) {
        this.age = age;
        this.name = name;
    }

}

public class test {
    public static void main(String[] args) {
        int[] a1 = {5, 3, 2, 4, 1};
        double[] a2 = {5.5, 3.3, 2.2, 4.4, 1.1};
        people tom = new people(18, "tom");
        people jerry = new people(17, "jerry");
        people jason = new people(20, "jason");
        people[] a3 = {tom, jerry, jason};
        List<people> l1 = new ArrayList<>();
        l1.add(tom);
        l1.add(jerry);
        l1.add(jason);
        List<Integer> l2 = new ArrayList<>();
        l2.add(5);
        l2.add(2);
        l2.add(3);
        l2.add(1);

        //sort升序排部分(左包右不包)
        Arrays.sort(a1, 2, 5);
        System.out.println(Arrays.toString(a1));


        //sort升序排序（int数组）
        Arrays.sort(a1);
        System.out.println(Arrays.toString(a1));


        //sort升序排序（double数组）
        Arrays.sort(a2);
        System.out.println(Arrays.toString(a2));


        //sort自定义接口
        /*
            int compare(Object o1, Object o2) 返回一个基本类型的整型
            如果要按照升序排序，
            则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
            如果要按照降序排序
            则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）
        */
        Arrays.sort(a3, new Comparator<people>() {
            @Override
            public int compare(people o1, people o2) {
                return Integer.compare(o1.age, o2.age);
            }
        });
        System.out.println((a3[0].age) + " " + (a3[1].age) + " " + (a3[2].age));


        //sort降序排序(整型）转为list再排序
        List tmp = Arrays.asList(a1);
        Collections.sort(tmp, Collections.reverseOrder());

        //list升序排序（整型）
        Collections.sort(l2);
        System.out.println(l2);


        //list降序排序（整型）
        Collections.sort(l2, Collections.reverseOrder());
        System.out.println(l2);


        //list排序（自定义接口）
        Collections.sort(l1, new Comparator<people>() {
            @Override
            public int compare(people o1, people o2) {
                return Integer.compare(o1.age, o2.age);
            }
        });
        System.out.println(l1.get(0).age + " " + l1.get(1).age + " " + l1.get(2).age);

    }
}