java實戰：多屬性排序

阿新 • • 發佈：2022-03-01

多屬性排序的核心點就是對Arrays.sort()和Collections.sort()方法的Comparator進行重寫

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<int[]>() {
            @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<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                    if(o1[0]>o2[0]){
                        return 1;
                    }else if(o1[0]<o2[0]){
                        return -1;
                    }else{
                        return o2[1]-o1[1];
                    }
            }
        });
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

場景3：按二維陣列的第一列升序排序，如果第一列值相同，就按第二例升序排序，如果第二列值相同，就按第3列升序排序，以此類推。。。

public static void main(String[] args) {
        int[][] arr = {{2, 6, 4}, {6, 5, 7}, {6, 1, 1}};
        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                for(int k=0;k<arr.length;k++){ // 下面這塊就表示：//如果按一條件比較結果相等，就使用第二個條件進行比較。
                    if(o1[k]>o2[k]){
                        return 1;
                    }else if(o1[k]<o2[k]){
                        return -1;
                    }else{
                        continue;
                    }
                }
                return 0;
            }
        });
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

總結：升序：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<String> ls = new LinkedList<>();
        ls.add("abdh");
        ls.add("bmkhy");
        ls.add("cbdga");
        ls.add("aasd");
//        Collections.sort(ls); //預設是按字典序列升序

        // 按首字母升序，如果第一列值相同，就按照第二列降序排列，以此類推
        Collections.sort(ls, new Comparator<String>() {
            @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<String> ls = new LinkedList<>();
        ls.add("abdh");
        ls.add("bmkhy");
        ls.add("cbdga");
        ls.add("aasd");
        Collections.sort(ls, new Comparator<String>() {
            @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結果：