Question

我正在尝试对以下数组进行排序：

int hitlist[][] = new int [17][2];

排序信息始终在hitlist[i][0]中，并且是数字，但是我找不到Arrays.sort的正确方法。

输入如下：

[0, 0] 
[4, 0] 
[3, 1] 
[4, 2] 
[4, 4] 
[5, 6] 
[4, 7] 
[4, 8] 
[1, 9] 
[4, 11] 
[4, 12] 
[2, 13] 
[4, 14] 
[4, 15] 
[0, 0] 
[0, 0] 
[0, 0]

现在我希望将其排序为：

[1, 9]
[2, 13]
[3, 1]
[4, 0]
[4, 2] 
[4, 4]
[4, 7] 
[4, 8]
[4, 11] 
[4, 12]
[4, 14] 
[4, 15]

Answer 1

如果要基于索引对数组进行排序，可以将Arrays::sort与Comparator::comparingInt一起使用

int index = 0;
Arrays.sort(hitlist, Comparator.comparingInt(arr -> arr[index]));

这里是Ideone

中的一个示例

修改

基于您的comment和comment，您希望在排序后忽略数组中的[0, 0]，在这种情况下，您可以使用：

int[][] hitlist = {{0, 0}, {4, 0}, {3, 1}, {4, 2}, {4, 4}, {5, 6}, {4, 7}, {4, 8}, {1, 9}, {4, 11}, {4, 12}, {2, 13}, {4, 14}, {4, 15}, {0, 0}, {0, 0}, {0, 0}};
int index = 0;
int[][] sortedArray = Arrays.stream(hitlist)
        .filter(arr -> arr[0] != 0 && arr[1] != 0)
        .sorted(Comparator.comparingInt(arr -> arr[index]))
        .toArray(int[][]::new);

Ideone demo

输出

[1, 9]
[2, 13]
[3, 1]
[4, 2]
[4, 4]
[4, 7]
[4, 8]
[4, 11]
[4, 12]
[4, 14]
[4, 15]
[5, 6]

Answer 2

尽管我更喜欢 YCF_L的 解决方案，但该实现使用带有整数数组比较器的Quick-Sort。这提供了更大的灵活性。

import java.util.Arrays;

/**
 * Based on Quicksort (right-most pivot) implementation from:  
 * https://www.programcreek.com/2012/11/quicksort-array-in-java/
 */
public class Sorter {
    private static interface IntArrayComparator {
        int compare(int[] a, int[] b);
    }

    public static void main(String[] args) {
        int hitlist[][] = new int[8][2];
        hitlist[4] = new int[] { 4, 10000 };
        hitlist[1] = new int[] { 1, 10 };
        hitlist[5] = new int[] { 5, 100000 };
        hitlist[0] = new int[] { 0, 1 };
        hitlist[2] = new int[] { 2, 100 };
        hitlist[7] = new int[] { 7, 10000000 };
        hitlist[3] = new int[] { 3, 1000 };
        hitlist[6] = new int[] { 6, 1000000 };

        quickSort(hitlist, (a, b) -> a[0] - b[0]);
        Arrays.asList(hitlist).stream().map(Arrays::toString).forEach(System.out::println);
    }

    public static void quickSort(int[][] arr, IntArrayComparator comparator) {
        quickSort(arr, comparator, 0, arr.length - 1);
    }

    public static void quickSort(int[][] arr, IntArrayComparator comparator, int start, int end) {
        int partition = partition(arr, comparator, start, end);
        if (partition - 1 > start) {
            quickSort(arr, comparator, start, partition - 1);
        }
        if (partition + 1 < end) {
            quickSort(arr, comparator, partition + 1, end);
        }
    }

    public static int partition(int[][] arr, IntArrayComparator comparator, int start, int end) {
        int[] pivot = arr[end];
        for (int i = start; i < end; i++) {
            if (comparator.compare(arr[i], pivot) < 0) {
                int[] temp = arr[start];
                arr[start] = arr[i];
                arr[i] = temp;
                start++;
            }
        }
        int[] temp = arr[start];
        arr[start] = pivot;
        arr[end] = temp;
        return start;
    }
}

结果

[0, 1]
[1, 10]
[2, 100]
[3, 1000]
[4, 10000]
[5, 100000]
[6, 1000000]
[7, 10000000]

Answer 3

这取决于您要对行还是对列进行排序。

让我们说您想对每一行进行排序。

for(int i=0; i < hitlist.size(); i++ {
     Array.sort(hitlist[i]);
}

排序列变得棘手，在这种情况下，您可以构造一个包含列值的新数组，然后将列排序或旋转为行（90度），将其排序为行，然后再次旋转（-90度）

如果您还有其他需要，则必须自己执行搜索。

希望这会有所帮助

Answer 4

您可以将int数组装箱为Integer数组，然后在lambda函数中对两个Integer对象（索引为0的对象）进行数字比较。

然后将比较器传递给Arrays.sort，它将根据比较器引起的顺序对其进行排序。

    Integer[][] array= {
            {1, 3},
            {10, 5},
            {4, 100},
            {12, 30} };

    Comparator<Integer[]> arrayComparator = (a1, a2) -> a1[0].compareTo(a2[0]);

    Arrays.sort(array, arrayComparator);

如何在Java

4 个答案:

结果