Java 按升序对整个二维数组进行排序

我想使用

Arrays.sort（）

按升序对二维数组进行排序

例如，我有一个数组：

[3,8,5]
[1,6,7]
[2,4,9]

排序后，输出应为：

[1,2,3]
[4,5,6]
[7,8,9]

编写了如下代码，但它按行排序：

包域；
导入java.util.array；
公开课练习{
私有int[][]矩阵={
{34, 2, 15, 12, 56},
{3, 67, 6, 21, 9},
{22, 5, 18, 65, 10},
{52, 36, 112, 90, 0},
{19, 48, 73, 16, 88}};
//方法来显示数组
公共void DisplayArray（）{
对于（int[]行：矩阵）{
System.out.println（Arrays.toString（row））；
}
}
公共空白排序（）{
对于（int[]行：矩阵）{
数组。排序（行）；
}
}
}

这个问题可以分为三个部分

将大小为

n

的每行的所有元素放在一个向量中

订购该向量

将其分解为大小为

n

使用您的示例输入

int[][] arr = { {3,8,5},{1,6,7},{2,4,9} };

方法：

int[][] sorted(int[][] in) {
    int[] all = new int[in.length * in.length]; // assumption: square matrix
    int i = 0;
    for (int[] row : in) {
        for (int el : row) {
            all[i] = el;
            i++;
        }
    }
    Arrays.sort(all); // sort all elements in single vector
    // put sorted elements in your "output" array
    int[][] out = new int[in.length][in.length];
    int row = 0;
    int col = 0;
    for (int el : all) {
        // note col,row and not row,col!
        out[col][row] = el;
        row++;
        if (row == in.length) {
            row = 0;
            col++;
        }
    }
    return out;
}

你有

int[][] sorted = sorted(arr);

---

这个问题可以分为三个部分

将大小为

n

的每行的所有元素放在一个向量中

订购该向量

将其分解为大小为

n

使用您的示例输入

int[][] arr = { {3,8,5},{1,6,7},{2,4,9} };

方法：

int[][] sorted(int[][] in) {
    int[] all = new int[in.length * in.length]; // assumption: square matrix
    int i = 0;
    for (int[] row : in) {
        for (int el : row) {
            all[i] = el;
            i++;
        }
    }
    Arrays.sort(all); // sort all elements in single vector
    // put sorted elements in your "output" array
    int[][] out = new int[in.length][in.length];
    int row = 0;
    int col = 0;
    for (int el : all) {
        // note col,row and not row,col!
        out[col][row] = el;
        row++;
        if (row == in.length) {
            row = 0;
            col++;
        }
    }
    return out;
}

你有

int[][] sorted = sorted(arr);

---

使用流，可以将2D数组转换为整数流，然后将其重新收集为2D数组：

公共静态int[]sort2D（int[]arr）{
int行=arr.length；
int cols=arr[0]。长度；
int[]行={0}；
返回数组.stream（arr）
.flatMapToInt（数组：：流）
.已排序（）
.boxed（）
.collect（收集器.groupingBy（x->row[0]+/cols））
.values（）
.stream（）
.map（r->r.stream（）.mapToInt（Integer:：intValue）.toArray（））
.toArray（int[]]：：新建）；
}

试验

int[]arr={
{9, 7, 5, 4},
{3, 12, 11, 8},
{6, 1, 2, 10}
};
int[][]排序=sort2D（arr）；
Arrays.stream（已排序）
.map（数组：：toString）
.forEach（System.out:：println）；

输出

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

更新
使用以下方法可以获得更简单的解决方案：

公共静态int[]sort2D（int[]arr）{
int行=arr.length；
int cols=arr[0]。长度；
AtomicInteger ix=新的AtomicInteger（0）；//int[]ix={0}；也可以使用
返回数组
.stream（arr）
.flatMapToInt（数组：：流）
.已排序（）
.收集(
（）->新建int[rows][cols]，//供应商创建结果数组
（a，x）->a[ix.get（）/cols][ix.getAndIncrement（）%cols]=x，//用排序后的数据填充
（arr1，arr2）->{}//没有要合并的内容
);
}

使用流，可以将2D数组转换为整数流，然后将其重新收集为2D数组：

公共静态int[]sort2D（int[]arr）{
int行=arr.length；
int cols=arr[0]。长度；
int[]行={0}；
返回数组.stream（arr）
.flatMapToInt（数组：：流）
.已排序（）
.boxed（）
.collect（收集器.groupingBy（x->row[0]+/cols））
.values（）
.stream（）
.map（r->r.stream（）.mapToInt（Integer:：intValue）.toArray（））
.toArray（int[]]：：新建）；
}

试验

int[]arr={
{9, 7, 5, 4},
{3, 12, 11, 8},
{6, 1, 2, 10}
};
int[][]排序=sort2D（arr）；
Arrays.stream（已排序）
.map（数组：：toString）
.forEach（System.out:：println）；

输出

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

更新
使用以下方法可以获得更简单的解决方案：

公共静态int[]sort2D（int[]arr）{
int行=arr.length；
int cols=arr[0]。长度；
AtomicInteger ix=新的AtomicInteger（0）；//int[]ix={0}；也可以使用
返回数组
.stream（arr）
.flatMapToInt（数组：：流）
.已排序（）
.收集(
（）->新建int[rows][cols]，//供应商创建结果数组
（a，x）->a[ix.get（）/cols][ix.getAndIncrement（）%cols]=x，//用排序后的数据填充
（arr1，arr2）->{}//没有要合并的内容
);
}

您可以试试这个。这里有我的推荐信

---

你可以试试这个。这里有我的推荐信

---

您可以先将此二维数组展平为一维，然后使用方法对平面数组进行排序，然后使用排序后的平面数组中的元素重新组合相同尺寸的二维数组：

//原始数组
int[]arr={
{3, 8, 5},
{1, 6, 7},
{2, 4, 9}};

//展平二维数组
int[]flatArr=Arrays.stream（arr）.flatMapToInt（Arrays:：stream）.toArray（）；
//分类
数组。排序（flatArr）；

//从平面阵列重新组装相同尺寸的二维阵列
AtomicInteger flatIndex=新的AtomicInteger（0）；
//遍历的行及其元素
//原始数组并按顺序填充
//包含平面阵列中的元素的新阵列
int[][]排序=数组.stream（arr）
.map（行->数组.stream（行）
.map（j->flatArr[flatIndex.getAndAdd（1）]）
.toArray（））
.toArray（int[]]：：新建）；

//输出
Arrays.stream（sorted）.map（Arrays:：toString）.forEach（System.out:：println）；
//[1,2,3]
//[4,5,6]
//[7,8,9]

---

另见：
•

---

•

您可以先将此二维数组展平为一维，然后使用方法对平面数组进行排序，然后使用排序后的平面数组中的元素重新组合相同尺寸的二维数组：

//原始数组
int[]arr={
{3, 8, 5},
{1, 6, 7},
{2, 4, 9}};

//展平二维数组
int[]flatArr=Arrays.stream（arr）.flatMapToInt（Arrays:：stream）。