Arrays.sort() 的一些用法

Arrays.sort() 的一些用法

介紹

　　之所以寫這篇隨筆是因為刷力扣時用到蠻多次這個api. 所以打算寫一篇記錄並了解。Arrays.sort()是經過調優排序算法，時間復雜度達到n*log(n)。
　　
Arrays.sort()重載了四類方法

• sort(T[] a)：對指定T型數組按數字升序排序。
• sort(T[] a,int formIndex, int toIndex)：對指定T型數組的指定范圍按數字升序排序。
• sort(T[] a, Comparator<? supre T> c): 根據指定比較器產生的順序對指定對象數組進行排序。
• sort(T[] a, int formIndex, int toIndex, Comparator<? supre T> c): 根據指定比較器產生的順序對指定對象數組的指定對象數組進行排序。

參數說明: 查看源碼就知道重載的數據類型包括 Object 一共有八個,其他七個就是基本類型: int , long , short , char , byte , float , double .

１、sort(T[] a)

對指定T型數組按指定數值升序排序。

int[] ints = new int[]{12, 4, 6, 7, 2, 8, 3, 9};// 按 數字
char[] chars = new char[]{'a', 'c', 'b', 'i', '+'};// 按 ascii 碼
byte[] bytes = new byte[]{7, 5, 6, 10, -1};// 按 字節數
Arrays.sort(ints);
Arrays.sort(chars);
Arrays.sort(bytes);
System.out.println(Arrays.toString(ints));
// 結果 ：[2, 3, 4, 6, 7, 8, 9, 12]
System.out.println(Arrays.toString(chars));
// 結果 ：[+, a, b, c, i]
System.out.println(Arrays.toString(bytes));
// 結果 ：[-1, 5, 6, 7, 10]

２、sort(T[] a,int formIndex, int toIndex)

對指定T型數組的指定范圍按指定數值升序排序。

int[] ints = new int[]{12, 4, 6, 7, 2, 8, 3, 9};// 按 數字
char[] chars = new char[]{'a', 'c', 'b', 'i', '+'};// 按 ascii 碼
byte[] bytes = new byte[]{7, 5, 6, 10, -1};// 按 字節數
Arrays.sort(ints, 2, 5);
Arrays.sort(chars, 2, 5);
Arrays.sort(bytes, 2, 5);
System.out.println(Arrays.toString(ints));
// 結果 ：[12, 4, 2, 6, 7, 8, 3, 9]
System.out.println(Arrays.toString(chars));
// 結果 ：[a, c, +, b, i]
System.out.println(Arrays.toString(bytes));
// 結果 ：[7, 5, -1, 6, 10]

３、sort(T[] a, Comparator<? supre T> c)

根據指定比較器產生的順序對指定對象數組進行排序.

(1). 一維數組降序排序

這里用降序演示一下;

 /*注意，要想改變默認的排列順序，不能使用基本類型（int,double, char）
而要使用它們對應的包裝類*/
Integer[] ints = new Integer[]{12, 4, 6, 7, 2, 8, 3, 9};
Arrays.sort(ints, Collections.reverseOrder());
System.out.println(Arrays.toString(ints));
// 結果 ：[12, 9, 8, 7, 6, 4, 3, 2]

也可以使用自定義規則

Arrays.sort(ints, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
// lambda 表達式
Arrays.sort(ints, (o1, o2) -> o2 - o1);

(2).二維數組按照第一維數組排序 升序

PS：這里提一下如果是 Integer數組 比較相等時用 equals 而不是用 == 。至於為什么請看 == 和 equals 的區別

int[][] nums=new int[][]{{1,3},{1,2},{5,1},{4,5},{3,3}};
//方法一
Arrays.sort(nums,new Comparator<int[]>(){
    @Override
    public int compare(int[] a,int[] b){
        // 當第一維相等時比較第二維的
        if(a[0] == b[0]){
            return a[1]-b[1];
        }else{
            return a[0]-b[0];
        }
    }
});

// 方法二，使用 lambda 表達式
Arrays.sort(nums,(a,b) -> a[0] == b[0] ? a[1]-b[1] : a[0]-b[0]);
for (int[] num : nums) {
    System.out.print(Arrays.toString(num));
}
// 結果 ： [1, 2][1, 3][3, 3][4, 5][5, 1]

(3).二維數組按照第二維數組排序 升序

int[][] nums=new int[][]{{1,3},{1,2},{5,1},{4,5},{3,3}};
//方法一
Arrays.sort(nums,new Comparator<int[]>(){
    @Override
    public int compare(int[] a,int[] b){
        // 當第二維相等時比較第一維的
        if(a[1] == b[1]){
            return a[0]-b[0];
        }else{
            return a[1]-b[1];
        }
    }
});

// 方法二，使用 lambda 表達式
Arrays.sort(nums,(a,b) -> a[1] == b[1]  ? a[0]-b[0] : a[1]-b[1]);
for (int[] num : nums) {
    System.out.print(Arrays.toString(num));
}
// 結果 ： [5, 1][1, 2][1, 3][3, 3][4, 5]

(3).二維數組 降序

對調返回值哪里的順序
也就是:

// 按第一維降序
if(a[0].equals(b[0]){
    return b[1]-a[1];
}else{
    return b[0]-a[0];
}
// 結果 ： [5, 1][4, 5][3, 3][1, 3][1, 2]

(4). 類的比較

其實這個方法最重要的還是類對象的比較
由於我們可以自定義比較器，所以我們可以使用策略模式，使得在運行時選擇不同的算法
這里就不說明了,會開個新隨筆記錄.

４、sort(T[] a, int formIndex, int toIndex, Comparator<? supre T> c)

這里就不用代碼說明了,就是根據指定比較器產生的順序對指定對象數組的指定對象數組進行排序。

參考網站 :

Arrays.sort()詳解
Java中Arrays.sort()自定義數組的升序和降序排序