java实战：多属性排序

多属性排序的核心点就是对Arrays.sort()和Collections.sort()方法的Comparator进行重写

1. Arrays.sort()的三种用法

1.1、Arrays.sort(int[] a)  这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。较常用

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

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

1.3、对Comparator进行重写，即多属性排序，以二维数组为例，共列举两种场景：

场景1：

public static void main(String[] args) {
        int[][] arr = {{2, 6, 4}, {6, 5, 7}, {6, 1, 1}};
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(int[] o1, int[] o2) {
               return o1[1]-o2[1]; // 按第2列升序排列   return o1[0]-o2[0] 表示按第一列排序
        });
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

场景:2：按二维数组的第一列升序排序，如果第一列值相同，就按第二例降序排序

public static void main(String[] args) {
        int[][] arr = {{2, 6, 4}, {6, 5, 7}, {6, 1, 1}};
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(int[] o1, int[] o2) {
                    if(o1[0]>o2[0]){
                        return 1;
                    }else if(o1[0]

场景3：按二维数组的第一列升序排序，如果第一列值相同，就按第二例升序排序，如果第二列值相同，就按第3列升序排序，以此类推。。。

public static void main(String[] args) {
        int[][] arr = {{2, 6, 4}, {6, 5, 7}, {6, 1, 1}};
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(int[] o1, int[] o2) {
                for(int k=0;ko2[k]){
                        return 1;
                    }else if(o1[k]


总结：升序：o1-o2  降序：o2-o1  如果compare() 入参是基本数据类型 或char类型可以直接用减号“-”， 
如果compare() 入参是Byte, Double, Integer, Float, Long 或 Short 这些包装类型，或者是String类型，可以替换如下：
升序：o1.compareTo(o2 )      降序：o2.compareTo(o1 ) 

Collections.sort()的用法

场景1：对于字符串类型的集合进行排序，按首字母升序，如果第一列值相同，就按照第二列降序排列。

public static void main(String[] args) {
        List ls = new LinkedList<>();
        ls.add("abdh");
        ls.add("bmkhy");
        ls.add("cbdga");
        ls.add("aasd");
//        Collections.sort(ls); //默认是按字典序列升序

        // 按首字母升序，如果第一列值相同，就按照第二列降序排列，以此类推
        Collections.sort(ls, new Comparator() {
            @Override
            public int compare(String o1, String o2) {
//                return o1.compareTo(o2); // 升序   如果是基本类型的包装类型，也可以用o1-o2,或o2-o1
                if (o1.charAt(0) > o2.charAt(0)) {
                    return 1;
                } else if (o1.charAt(0) < o2.charAt(0)) {
                    return -1;
                } else { // 即o1.charAt(0) = o2.charAt(0) 返回值是0
                    return o2.charAt(1) - o1.charAt(1);
                }
            }
        });

        for (int i = 0; i < ls.size(); i++) {
            System.out.println(ls.get(i));
        }
    }



场景2：对于字符串类型的集合进行排序，按首字母升序，如果第一列值相同，就按照第二列升序排列，如果第2列值相同，就按照第3列升序排列，以此类推。。

 public static void main(String[] args) {
        List ls = new LinkedList<>();
        ls.add("abdh");
        ls.add("bmkhy");
        ls.add("cbdga");
        ls.add("aasd");
        Collections.sort(ls, new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                int len = Math.min(o1.length(), o2.length());
                for (int k = 0; k < len; k++) {
                    if (o1.charAt(k) > o2.charAt(k)) {
                        return 1;
                    } else if (o1.charAt(k) < o2.charAt(k)) {
                        return -1;
                    } else {
                        continue;
                    }
                }
                return 0;
            }
            });


        for (int i = 0; i < ls.size(); i++) {
            System.out.println(ls.get(i));
        }
    }



场景2结果：