我希望根据第一列中的值对以下阵列进行排序，并在输入二维阵列中保存行的初始位置。

int [][]intervals =
{
    {3,4},
    {2,3},
    {1,2},
};

输出将是

{1,2,2}
{2,3,1}
{3,4,0}

这里第三列是输入二维阵列中行的初始位置。

uj5u.com热心网友回复：

您可以相应地进行杠杆化Arrays.sort并通过 a Comparator。这将适用于您的情况：

        int [][] intervals =
                {
                        {3,4},
                        {2,3},
                        {1,2},
                };

        int mRows = intervals.length;
        int nCols = intervals[0].length;

        int [][]intervalsNew = new int[mRows][nCols   1];

        for (int i = 0; i < mRows; i  ) {
            intervalsNew[i] = Arrays.copyOf(intervals[i], nCols   1);
            intervalsNew[i][nCols] = i;
        }

        Arrays.sort(intervalsNew, new Comparator<int[]>() {
            public int compare(int[] a, int[] b) {
                return Double.compare(a[1], b[1]);
            }
        });

        for (int i = 0; i < mRows; i  ) {
            System.out.println(Arrays.toString(intervalsNew[i]));
        }

输出：

[1, 2, 2]
[2, 3, 1]
[3, 4, 0]

uj5u.com热心网友回复：

我对某些方法的了解比 mantri 少，因此我在这里严重依赖流，并且代码更冗长。这是我的尝试：

public class Intervals {

    public static void main(String[] args) {
    int[][] intervals = { { 3, 4 }, { 2, 3 }, { 1, 2 }, };

    // Convert to List to make easier to work on.
    List<List<Integer>> outer = new ArrayList<>();
    for (int[] x : intervals) {
        List<Integer> inner = new ArrayList<>();
        for (int y : x) {
        inner.add(y);
        }
        outer.add(inner);
    }

    // Create list of ints 0,1,2,3 to add to end.
    List<Integer> range = IntStream.rangeClosed(0, outer.size() - 1)
                                   .boxed()
                                   .collect(Collectors.toList());

    range.stream()
         .forEach(i -> {
             outer.get(i)
                  .add(i);
         });

    List<int[]> temp_new_intervals = new ArrayList<>();

    outer.stream()
         .sorted((c1, c2) -> {
             if (c1.get(0) > c2.get(0)) {
             return 1;
             } else if (c1.get(0) == c2.get(0)) {
             return 0;
             } else {
             return -1;
             }
         })
         .forEach(arr -> {
             // Because arr is Object [] we need to make it int[]
             Object[] objects = arr.toArray();
             int[] ints = Arrays.stream(objects)
                                .mapToInt(o -> (int) o)
                                .toArray();

             temp_new_intervals.add(ints);

         });

    int[][] new_intervals = new int[outer.size()][];

    for (int i = 0; i < outer.size(); i  ) {
        new_intervals[i] = temp_new_intervals.get(i);
    }

    for (int[] x : new_intervals) {
        System.out.println(Arrays.toString(x));
    }

    }

}

输出：

[1, 2, 2]
[2, 3, 1]
[3, 4, 0]