java sort方法详解_java排序sort方法

JAVA

ARRAYS.SORT 方法

    static void sort(ElementType[] a)
    默认为升序排序
    static void sort(ElementType[] a, int FromIndex, int ToIndex)
    在指定范围（FromIndex, ToIndex）内升序排序
    static void sort(T[] a, Comparator<? super T> c)
    根据指定的比较器指定的顺序，对指定的对象数组进行排序。
1
2
3
4
5
6

这里对指定顺序的sort详细记录。

底层原理：插入排序+二分查找

开始的默认0索引的数据是有序序列，然后遍历数组后面的每一个元素，将每一个元素插入到前面有序序列的指定地方。

comparator比较器

Comparator是一个接口，需要重写里面的compare函数。
这里可以使用匿名内部函数类

    这里以int a[]数组为例
    Arrays.sort(a, new Comparator<int[]>() {
        @Override
        public int compare(int[] o1, int[] o2) {
            return [返回值];
        }
    });
1
2
3
4
5
6
7

1. 返回值为负数：将o1与o2前面的数进行比较
2. 返回值为正数，将o1与o2后面的数进行比较
3. 返回值为0,同正数。

return o1 - o2;
升序：

1. o1 > o2时将o1与o2后面的数进行比较
2. o1 < o2时将o1与o2前面的数进行比较
3. o1 == o2时可插入

return o2 - o1:
降序:

1. o1 > o2时将o1与o2前面的数进行比较
2. o1 < o2时将o1与o2后面的数进行比较
3. o1 == o2时可插入

注意上面的查找比较的原理是二分查找

另外还有更加简单的Lambda表达式写法

    sort(数组名， 排序规则)
    升序：
    sort(arr, (x, y) -> x - y);
    降序：
    sort(arr, (x, y) -> x - y);
1
2
3
4
5

sort可以对各种对象进行排序，比如下面的二维数组：
a = { {3, 3}, {2, 2}, {4, 4}, {5, 5}, {1, 1} };

    以第一个元素为关键字进行升序排序时：
    sort(a, (x, y) -> x[0] - y[0]);
    结果为 a = {{1,1}, {2,2}, {3,3}, {4,4}, {5,5}}
    以第一个元素为关键字进行降序排序时：
    sort(a, (x, y) -> y[0] - x[0]);
    结果为 a = {{5,5}, {4,4}, {3,3}, {2,2}, {1,1}}
    
    如果要以第二个元素为关键字进行排序是，将x[0]-y[0]变为x[1]-y[1]即可
1
2
3
4
5
6
7
8

除了多维数组也可以对类选择关键字进行排序：

先定义一个类：
class Point { //这里是否构造函数都可以
    private int val;
    public int getVal() {
        return this.val;
    }
    public void setVal(int val) {
        this.val = val;
    }
}
public class testSort {
    public static void main(String[] args) throws Exception {
        Point[] point = new Point[3];
        // 注意下面的初始化是必须的！！！
        for(int i = 0; i < point.length; i ++)
            point[i] = new Point();
        for(int i = 0; i < point.length; i ++) {
            point[i].setVal(i);
        }
        // 降序：
        Arrays.sort(point, (x, y) -> y.getVal()- x.getVal());
        for(int i = 0; i < point.length; i ++) {
            System.out.printf("point[%d] = %d\n", i, point[i].getVal());
        }
    }
}
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

结果：

point[0] = 2
point[1] = 1
point[2] = 0
1
2
3

测试代码：

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

class Point {
    private int val;

//    public void Point() {
//        this.val = 3;
//    }
    public int getVal() {
        return this.val;
    }
    public void setVal(int val) {
        this.val = val;
    }


}

public class testSort {

    public static void main(String[] args) throws Exception {
        int[][] a = new int[5][2];
        for(int i = 0; i < 5; i ++) {
            a[i][0] = i;
            a[i][1] = i;
        }
        Arrays.sort(a, (x, y) -> (x[0] - y[0]));
        System.out.println("-----------升序---------");
        for(int i = 0; i < 5; i ++) {
            System.out.printf("a[%d] = {%d %d}\n",i, a[i][0], a[i][1]);
        }
        System.out.println();

        Arrays.sort(a, (x, y) -> (y[0] - x[0]));
        System.out.println("-----------降序---------");
        for(int i = 0; i < 5; i ++) {
            System.out.printf("a[%d] = {%d %d}\n",i, a[i][0], a[i][1]);
        }
        System.out.println();
        // 匿名函数方法
//        Arrays.sort(a, new Comparator<int[]>() {
//            @Override
//            public int compare(int[] o1, int[] o2) {
//                return o1 - o2;
//            }
//        });
        System.out.println("-------对类排序-----");
        Point[] point = new Point[3];
        // 注意下面的初始化是必须的！！！
        for(int i = 0; i < point.length; i ++)
            point[i] = new Point();
        for(int i = 0; i < point.length; i ++) {
            point[i].setVal(i);
        }
        // 降序：
        Arrays.sort(point, (x, y) -> y.getVal()- x.getVal());
        for(int i = 0; i < point.length; i ++) {
            System.out.printf("point[%d] = %d\n", i, point[i].getVal());
        }

    }
}
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