• 1. 一般思路
• 2. 直接排序，利用庫函式
• 3. 一維陣列,帶利用庫函式的逆序排序
• 4. 一維陣列，帶Comparator的排序 ，逆序排序
• 5. 二維陣列，Comparator排序,
• 6. 二維陣列，lambda 簡化排序

1. 一般思路

就是用現成的庫函式,一般是呼叫Arrays.sort()方法。
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): 根據指定比較器產生的順序對指定物件陣列的指定物件陣列進行排序。

一般的呼叫Arrays.sort()就ok了，如果是自定義型別，就需要加一個Comparator類，裡面實現。

   * @param o1 the first object to be compared.
     * @param o2 the second object to be compared.
     * @return a negative integer, zero, or a positive integer as the
     *         first argument is less than, equal to, or greater than the
     *         second.
     int compare(T o1, T o2)
 

返回是一個int型別，負數是代表第一個數01小於o2，正數是代表大於。跟golang 的不大一樣，感覺golang的比較函式邏輯更自然一點，直接返回 bool型別。詳情請見 go-sort排序

2. 直接排序，利用庫函式

比如我有一個數組

Integer[] a = { 9, 8, 7, 2, 3, 4, 1, 0, 6, 5 }; 

Arrays.sort(a);

3. 一維陣列,帶利用庫函式的逆序排序

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

4. 一維陣列，帶Comparator的排序 ，逆序排序

  Arrays.sort(a,new Comparator<Integer>(){
            public int compare(Integer x,Integer y){
                return y-x;
            }
     });
 

這個可以用lambda 簡化成:

Arrays.sort(a,(Integer x,Integer y)->{return y-x;});

5. 二維陣列，Comparator排序,

int[][] nums = new int[][]{{2,4},{5,6},{1,2},{7,8},{7,9}};

一個典型的場景是合併區間.

Arrays.sort(nums,new Comparator<int[]>(){
             public int compare(int[] a, int[] b){
                 return a[0]-b[0];
             }
         });

Comparator 裡面的T是 int[] , compare 函式引數也是int[] ，要一致。

6. 二維陣列，lambda 簡化排序

 Arrays.sort(nums,(a,b)->{return a[0]-b[0];});