java中的Arrays.sort()

1.Arrays.sort(int [] a)

Arrays.sort(int [] a)

传入数组直接从小到大排序

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

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

传入数组直接从给定坐标从小到大排序

使用规则则为从fromIndex<=a数组<toIndex

3.Arrays.sort(T[] a,int fromIndex, int toIndex, Comparator<? super T> c)

Arrays.sort(T[] a,int fromIndex, int toIndex, Comparator<? super T> c)

但注意得通过包装类型数组，基本类型数组是不行滴，既要用new Integer[] 而不是 new int[]

(1)实现倒序（从大到小），用java自带的函数Collections.reverseOrder（）

public class text1
{
    public static void main(String []args)
    {
        Integer[] integers=new Integer[]{2,324,4,4,6,1};
        Arrays.sort(integers, Collections.reverseOrder());
        for (Integer integer:integers)
        {
            System.out.print(integer+" ");
        }
    }
}

(2)实现倒序（从大到小），使用自定义的排序方法，自定义排序方法需要用java.util.Comparetor接口中的compare方法

public class text1
{
    public static void main(String []args)
    {
        Integer[] integers=new Integer[]{2,324,4,4,6,1};
        Arrays.sort(integers, new Comparator<Integer>() {

            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        for (Integer integer:integers)
        {
            System.out.print(integer+" ");
        }
    }
}

4.二维数组排序

1996. 游戏中弱角色的数量

这道题给二维数组排序，攻击值从大到小排序，相同攻击值防御值从小到大排序

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] a = new int[n][2];
        for (int i = 0; i < n; i++) {
            for(int j=0; j<2;j++){
                a[i][j]=scanner.nextInt();
            }
        }
        System.out.println(numberOfWeakCharacters(a));


    }

    public static int numberOfWeakCharacters(int[][] properties) {
        Arrays.sort(properties, (o1, o2) -> {
            return o1[0] == o2[0] ? (o1[1] - o2[1]) : (o2[0] - o1[0]);
        });
        int maxDef = 0;
        int ans = 0;
        for (int[] p : properties) {
            if (p[1] < maxDef) {
                ans++;
            } else {
                maxDef = p[1];
            }
        }
        return ans;
    }

compare(int[] x,int[] y) 来“比较x和y的大小”。

若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。

也就是说，有如下两种理解：

1. 返回正数意味着降序排列，返回负数意味着升序排列。

2. 想升序就return x-y；想降序就y-x。

以下代码是一样的

Arrays.sort(properties, (o1, o2) -> {
            return o1[0] == o2[0] ? (o1[1] - o2[1]) : (o2[0] - o1[0]);
});

Arrays.sort(a,new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
    // TODO Auto-generated method stub
         return o1[0] == o2[0] ? o1[1]-o2[1] : o2[0]- o1[0];
    }
}