Question

我有一个名为interval [g] [2]的二维数组，其中g是某个数字。目前，我试图通过增加第一个元素的顺序来排序数组，如果它们相等，则按第二个元素中的降序排序。

我试过两种方式：

1）使用Java 8的Comparator.comparing方法：

Arrays.sort(interval, Comparator.comparing((int[] arr) -> arr[0]));

2）使用Arrays.sort ：

Arrays.sort(interval, new Comparator<int[]>() {
    @Override
    public int compare(int[] s1, int[] s2) {
        if (s1[0] > s2[0])
            return 1;
        else if (s1[0] < s2[0])
            return -1;
        else {
            if(s1[1] < s2[1])
                return 1;
            else if (s1[1] > s2[1])
                return -1;
            else
                return 0;
        }
    }
});

第一种方法返回部分排序的列表。

[[0, 10], [10, 30], [30, 50]]
[[0, 10], [3, 19], [35, 45]]
[[10, 30], [27, 33], [30, 50]]
[[-10, 10], [0, 20], [35, 45]]
[[10, 30], [20, 40], [30, 50]]
[[0, 20], [8, 28], [37, 43]]
[[0, 20], [15, 35], [37, 43]]
[[0, 0], [8, 28], [10, 40]]

正如您所看到的，它是在一组三元组中对事物进行排序。

第二种方法根本不对数组进行排序。我可以不使用原始数据类型排序吗？有人可以建议吗？

Answer 1

我认为你正在寻找这个：

Arrays.sort(interval, Comparator.comparingInt((int[] arr) -> arr[0]).thenComparing(Comparator.comparingInt((int[] arr) -> arr[1]).reversed()));

或者，如果您想使用自定义Comparator：

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

Answer 2

int[][] interval = new int[][] { {0, 10}, {10, 30}, {30, 50}, {0, 10}, {3, 19}, {35, 45}, {10, 30}, {27, 33}, {30, 50}, {-10, 10}, {0, 20}, {35, 45}, {10, 30}, {20, 40}, {30, 50}, {0, 20}, {8, 28}, {37, 43}, {0, 20}, {15, 35}, {37, 43}, {0, 0}, {8, 28}, {10, 40} };

Arrays.sort(interval, Comparator.<int[]>comparingInt(arr -> arr[0]).thenComparing(arr -> arr[1], Comparator.<Integer>naturalOrder().reversed()));

Stream.of(interval).forEachOrdered(ints -> System.out.println(Arrays.toString(ints)));

使用Java Comparator对2d数组进行排序

2 个答案: