Java 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): 根据指定比较器产生的顺序对指定对象数组的指定对象数组进行排序。

1、sort(T[] a)

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]

2sort(T[], int fromIndex, int toIndex)

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]

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

降序排序：

 /*注意，要想改变默认的排列顺序，不能使用基本类型（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]

也可以自定义排序：

这个方法复杂了

public class sort {
    private static class MyComparator implements Comparator<Integer>{
        @Override
        public int compare(Integer t0, Integer t1) {
            if (t0 > t1)
            {
                return -1;
            }
            else if (t0 < t1)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
    }
    public static void main(String[] args) {
        MyComparator myComparator = new MyComparator();
        Integer nums[] = {2,1,6,4,8,9,0};
        Arrays.sort(nums, myComparator);
        for (int i : nums) {
            System.out.println(i);
        }
    }
}

补充：return 1 为升序排序， return -1 为降序排序

简便的方法：

 Arrays.sort(nums, myComparator);
        Arrays.sort(nums, Collections.reverseOrder());
        Arrays.sort(nums, new Comparator<Integer>() {
            @Override
            public int compare(Integer t0, Integer t1) {
                return t1 -t0;
            }
        });

更简便的方法：（lambda表达式）

 Arrays.sort(nums, (t0, t1) -> t1 - t0);

二维数组按照一维数组排序 升序

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[] t0, int[] t1) {
                if (t0[0] == t1[0]) {
                    return t0[1] - t1[1];
                }else {
                    return t0[0] - t1[0];
                }
            }
        });
        for (int[] num : nums) {
            System.out.println(Arrays.toString(num));
        }

lambda表达式：

 Arrays.sort(nums, (x, y) -> x[0] == y[0] ? x[1] - y[1] : x[0] - y[0]);
        for (int[] num : nums) {
            System.out.println(Arrays.toString(num));
        }

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

根据指定比较器产生的顺序对指定对象数组的指定对象数组进行排序