Java Arrays.sort可以对很多数据类型进行排序，但是当需要对一个比较特殊的数组进行排序的时候，比如一个二维数组，我们要以每组的第一个数大小来排序，则需要我们自己定义一个比较方法。

先看看源码

    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

//-----------------------------------------------------------------------------------------

    private static <T> void legacyMergeSort(T[] a, Comparator<? super T> c) {
        T[] aux = a.clone();
        if (c==null)
            mergeSort(aux, a, 0, a.length, 0);
        else
            mergeSort(aux, a, 0, a.length, 0, c);
    }

//-----------------------------------------------------------------------------------------

    @SuppressWarnings({"rawtypes", "unchecked"})
    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low, int high, int off,
                                  Comparator c) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)//重点在这里
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off, c);
        mergeSort(dest, src, mid, high, -off, c);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (c.compare(src[mid-1], src[mid]) <= 0) {
           System.arraycopy(src, low, dest, destLow, length);
           return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

该方法支持我们传入一个Comparator类，并重写他的compare方法即可实现我们的需求

/*
 * @Description: 
 * @Author: Mr.C
 * @Date: 2020-10-19 08:21:45
 * @LastEditTime: 2020-10-30 12:49:41
 * @LastEditors: Mr.C
 */
import java.util.Arrays;
import java.util.Comparator;

class Solution {
    public static void main(String[] args) {
    	int[][] arr = new int[3][2];
    	arr[0][0] = 5;
    	arr[0][1] = 3;
    	arr[1][0] = 1;
    	arr[1][1] = 4;
    	arr[2][0] = 6;
    	arr[2][1] = 2;
    	for (int i = 0; i < arr.length; i++) {
    			System.out.println(arr[i][0]+","+arr[i][1]);
    	}
    	System.out.println();
    	Arrays.sort(arr, new Comparator<int[]>() {
    		public int compare(int[] a, int[] b) {
    			return a[0]-b[0];
    		}
    	});

    	for (int i = 0; i < arr.length; i++) {
    			System.out.println(arr[i][0]+","+arr[i][1]);
    	}
    }
}

/*结果
5,3
1,4
6,2

1,4
5,3
6,2
*/

也就是，compare方法返回的值如果大于0，则交换位置，所以我们用a[0]-b[0]来比较数组第一个数的大小。