Java 反转二维数组的每一行

我想创建一个二维数组的反向数组，这样原始数组的每一行都是反向的（不反转列）

也就是说，如果这是输入数组：

1 2 3
3.2.1
2.13

这是所需的输出：

3.2.1
1 2 3
3.1.2

问题是我得到的输出完全错误

这是我的代码：

public class Test {
    public static void main(String[] args) {
        int[][] forward = { 
                { 1, 2, 3 }, 
                { 3, 2, 1 }, 
                { 2, 1, 3 } 
            };

        int rows = forward.length;
        int cols = forward[0].length;
        int[][] reverse = new int[rows][cols];

        for (int i = rows - 1; i >= 0; i--) {
            for (int j = cols - 1; j >= 0; j--) {
                reverse[rows - 1 - i][cols - 1 - j] = forward[i][j];
            }
        }

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print(reverse[i][j]);
                if (j < cols - 1)
                    System.out.print(", ");
            }
            System.out.println();
        }
    }
}

公共类测试{
公共静态void main（字符串[]args）{
int[][]向前={
{ 1, 2, 3 }, 
{ 3, 2, 1 }, 
{ 2, 1, 3 } 
};
int rows=forward.length；
int cols=正向[0]。长度；
int[][]反向=新的int[行][cols]；
对于（int i=rows-1；i>=0；i--）{
对于（int j=cols-1；j>=0；j--）{
反向[行-1-i][cols-1-j]=正向[i][j]；
}
}
对于（int i=0；i

我想反向打印数组中的每一行

问题是，在循环中，不仅要反转列，还要反转行

reverse[rows - 1 - i][cols - 1 - j] = forward[i][j];

这将导致阵列旋转180度

若您只想反转行的内容，则意味着您想反转其列的顺序（您已经处理了这些列）。所以不是

reverse[rows - 1 - i][cols - 1 - j] = forward[i][j];

使用

---

顺便说一句，您不必按相反顺序循环行或列

for (int i = rows - 1; i >= 0; i--) {

简单的forward for循环也可以做到这一点，并且更具可读性

for (int i = 0; i < rows; i++) {

for（int i=0；i

在倒车循环中添加了以下行：

System.out.println("reverse[" + (rows - 1 - i) + "][" + (cols - 1 - j) + "] = forward[" + i + "][" + j + "]");

这就是我得到的：

反向[0][0]=正向[2][2]
反向[0][1]=正向[2][1]
反向[0][2]=正向[2][0]
反向[1][0]=正向[1][2]
反向[1][1]=正向[1][1]
反向[1][2]=正向[1][0]
反向[2][0]=正向[0][2]
反向[2][1]=正向[0][1]
反向[2][2]=正向[0][0]

---

你所做的是混合行

对于

正向

和

反向

，反向循环应在相同的行号上进行：

for (int i = 0; i < rows; i++) {
    for (int j = cols - 1; j >= 0; j--) {
        reverse[i][cols - 1 - j] = forward[i][j];
    }
}

for（int i=0；i=0；j--）{
反向[i][cols-1-j]=正向[i][j]；
}
}

通过这种方式，我们可以获得所需的行为：

反向[0][0]=正向[0][2]
反向[0][1]=正向[0][1]
反向[0][2]=正向[0][0]
反向[1][0]=正向[1][2]
反向[1][1]=正向[1][1]
反向[1][2]=正向[1][0]
反向[2][0]=正向[2][2]
反向[2][1]=正向[2][1]
反向[2][2]=正向[2][0]

---

你的问题是什么？到目前为止你有什么代码？没有人会为你编写代码。请正确解释你的问题…我不明白你有什么输入和什么输出你还没有问问题（以

？

结尾的问题）或者显示了您的代码…逻辑是什么？如果说行中每行有4个元素，我们无法理解期望的结果是什么。最重要的是，到目前为止您尝试了什么？我的问题已经解决了Tnx PSHEMO欢迎您。无论如何，由于您是堆栈溢出新手，您可能不知道该机制。简言之，如果有一些答案（或很少）解决您的问题，然后您可以将其中一个（您最喜欢的或最终使用的）标记为解决方案。

for (int i = 0; i < rows; i++) {
    for (int j = cols - 1; j >= 0; j--) {
        reverse[i][cols - 1 - j] = forward[i][j];
    }
}