Arrays.sort()用法

1、Arrays.sort(int[] a)

这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。

2、Arrays.sort(int[] a, int fromIndex, int toIndex)

这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序哦！

1，2这两种直接使用数组对象自身的自然排序，要能通过sort直接调用排序，需要数组内元素对象在定义类时继承自然排序接口Comparable并实现compareTo方法

3、public static void sort(T[] a,int fromIndex,int toIndex, Comparator<? super T> c)

这其实是对数组内对象进行定制排序，传入Comparator接口，实现其compare方法
上面有一个拘束，就是排列顺序只能是从小到大，如果我们要从大到小，就要使用这种方式

  public class Main {
      public static void main(String[] args) {
          //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
         //而要使用它们对应的类
         Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        //定义一个自定义类MyComparator的对象
         Comparator cmp = new MyComparator();
         Arrays.sort(a, cmp);
         for(int i = 0; i < a.length; i ++) {
             System.out.print(a[i] + " ");
         }
     }
}
//Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
//而不是extends Comparator
class MyComparator implements Comparator<Integer>{
     @Override
     public int compare(Integer o1, Integer o2) {
        //如果n1小于n2，我们就返回正值，如果n1大于n2我们就返回负值，
         //这样颠倒一下，就可以实现反向排序了
         if(o1 < o2) {
             return 1;
         }else if(o1 > o2) {
            return -1;
         }else {
             return 0;
        }
     }
    
}

对于int[]型数组，为了配合泛型使用，要将数组设为Integer[]型数组

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    while (scanner.hasNext()) {
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        Integer[] result = new Integer[n + 1];
        for (int i = 0; i <= n; i++) {
            result[i] = i;
        }
        Arrays.sort(result, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                String s1 = String.valueOf(o1);
                String s2 = String.valueOf(o2);
                return s1.compareTo(s2);
            }
        });
        System.out.println(result[m]);
    }
}

4、二维数组定制排序：

实现定制排序comparator

int [][]a = new int [5][2];

//定义一个二维数组，其中所包含的一维数组具有两个元素
对于一个已定义的二位数组a进行如下规则排序,首先按照每一个对应的一维数组第一个元素进行升序排序（即a[][0]）,若第一个元素相等,则按照第二个元素进行升序排序（a[][1]）。(特别注意,这里的a[][0]或者a[][1]在java中是不能这么定义的,这里只是想说明是对于某一个一维数组的第0或1个元素进行排序)

Arrays.sort(a, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
        if (o1[0]==o2[0]) return o1[1]-o2[1];
            return o1[0]-o2[0];
        }
    }
);

其中o1[1]-o2[1]表示对于第二个元素进行升序排序如果为o2[1]-o1[1]则表示为降序。

参考：

https://blog.csdn.net/weixin_39674445/article/details/111885150
https://blog.csdn.net/tt_twilight/article/details/70859804