在java中，有没有一种方法可以反转多维数组中的特定数组？

我知道如何操作和创建多维数组，但我不知道数组的所有util和特性。我想知道的是，如果我有一个大小为

[5][4]

的2D数组，我可以在第一行按顺序打印，第二行按顺序打印，第三行按顺序打印吗。。。等等

例如：

[1 2 3 4] //in order
[8 7 6 5] //reverse
[9 10 11 12] //in order
[16 15 14 13] //reverse
[17 18 19 20] //in order

正如我的老师所说“定义一个大小为m×n的二维数组。写一个从1到m×n的数字初始化这个数组的方法，方法如下：第一行，从左到右初始化元素；第二行，从右到左初始化；然后切换顺序。例如，如果m=5；n=4；阵列应初始化为：

---

我不确定是否应该使用temp方法或其他循环方法来执行此操作。

您不能直接将其反转。但您可以使用循环并反转备选行：

void reversearlay（）{
整数[][]arr={
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16},
{17, 18, 19, 20}};
对于（int i=1；i

int[]arr=newint[]{
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16}};
AtomicInteger计数器=新的AtomicInteger（0）；
Arrays.stream（arr.forEach）（ints->{
System.out.println（Arrays.stream（ints）
.mapToObj（字符串：：valueOf）
.减少（（a，b）->
counter.get（）%2==0？a+“”+b:b+“”+a.get（））；
counter.incrementAndGet（）；
});

---

此代码使用流API来迭代数组。第一个流迭代单级数组，第二个流迭代它们的元素，然后形成一个字符串。此外，根据计数器值，项目从左到右或从右到左组合。

您可以使用“蛇顺序”创建这样的数组“完全不进行排序，使用流中的流或循环中的循环：

---

intm=5；
int n=4；
int[][]arr=IntStream
//创建数组的行
.range（0，m）.mapToObj（行->输入流）
//为每行创建单元格，其中
//值是从1到[m*n]的数字
.范围（0，n）.映射（单元格->{
int val=行*n；
如果（第%2行==0）
//偶数行：
//直序
val+=细胞+1；
其他的
//奇数行：
//逆序
val+=n-细胞；
返回val；
})
//返回int[]数组
.toArray（））
//返回int[][]二维数组
.toArray（int[]]：：新建）；

---

intm=5；
int n=4；
int[]arr=新的int[m][n]；
//创建数组的行
对于（int行=0；行

---

Arrays.stream（arr.map）（Arrays:：toString.forEach（System.out:：println）；
// [1, 2, 3, 4]
// [8, 7, 6, 5]
// [9, 10, 11, 12]
// [16, 15, 14, 13]
// [17, 18, 19, 20]

---

另见：
•
•

如果我有一个[5][4]大小的2D数组，我可以在 第一行按顺序排列，第二行按相反顺序排列，第三行按顺序排列 订购。。。等等

不清楚您希望如何使用输出，但这里有一种文字方法：

publicstaticvoidmain（字符串[]args）{
int[][]值=新的int[][]{
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16}
};
对于（int r=0；r0；c--）{
系统输出打印（值[r][c]+“”）；
}
System.out.println（值[r][0]）；
}
}
}

输出：

1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13

---

不像嵌套循环那样高效，可以简单地从1迭代到20，并确定行

i

和列

j

final int M = 5;
final int N = 4;
int[][] matrix = new int[M][N];

IntStream.range(0, M*N)
    .forEach(no -> { // no = 0, 1, 2, ... , M*N-1
        int i = no / N; // Row.
        int j = no % N; // Increasing column (for even row).
        if (i % 2 == 1) { // Odd row.
           j = N - 1 - j; // Decreasing column.
        }
        matrix[i][j] = no + 1;
    });

i%2

是模2，其余部分除以2，因此0表示偶数，1表示奇数

或者使用更多的语言功能：

IntStream.range(0, N)
    .forEach(i -> {
        int no = N * i;
        IntUnaryOperator jToValue = i % 2 == 0
            ? j -> no + 1 + j
            : j -> no + N - 1 -j;
        Arrays.setAll(matrix[i], jToValue);
    });

这里

Arrays.setAll（int[]，（int index）->int）

根据索引填充数组

关于存在一些好函数的问题：

您可能看到了

列表。反向
；不存在
Arrays.reverse
，因此
Arrays.setAll
似乎是最好的。在这种情况下，如果值增加，理论上也可以对所有奇数行进行反向排序。但只有一个技巧，和排序成本

有趣的是，有这么多的解决方案。你可以拿着尾巴摇狗，而不是摇狗的尾巴