不像嵌套循环那样有效，可以简单地从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)` 基于索引填充数组。
关于有什么好功能的问题：
你可能看到了 `List.reverse` ; 不存在 `Arrays.reverse` ，因此 `Arrays.setAll` 似乎是最好的。在这种情况下，如果值在增加，理论上也可以对所有奇数行进行反向排序。但只有一个技巧，和分类成本。
有趣的是，有这么多的解决办法。不用摇动狗的尾巴，人们可以拿着尾巴摇动狗。

使用流中的流或循环中的循环，可以创建具有“蛇顺序”的数组，而无需进行任何排序：

int m = 5;
int n = 4;

int[][] arr = IntStream
        // create rows of array
        .range(0, m).mapToObj(row -> IntStream
                // for each row create cells where
                // values are numbers from 1 to [m * n]
                .range(0, n).map(cell -> {
                    int val = row * n;
                    if (row % 2 == 0)
                        // even rows:
                        // straight order
                        val += cell + 1;
                    else
                        // odd rows:
                        // reverse order
                        val += n - cell;
                    return val;
                })
                // return int[] array
                .toArray())
        // return int[][] 2d array
        .toArray(int[][]::new);

int m = 5;
int n = 4;

int[][] arr = new int[m][n];

// create rows of array
for (int row = 0; row < m; row++) {
    // for each row create cells where
    // values are numbers from 1 to [m * n]
    for (int cell = 0; cell < n; cell++) {
        int val = row * n;
        if (row % 2 == 0)
            // even rows:
            // straight order
            val += cell + 1;
        else
            // odd rows:
            // reverse order
            val += n - cell;
        arr[row][cell] = val;
    }
}

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]

另请参见：
•在java中，如何将矩阵逆时针旋转90度？
•是否有其他方法删除字符串中的所有空白？

int[][] arr = new int[][]{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
        {13, 14, 15, 16}};

AtomicInteger counter = new AtomicInteger(0);
Arrays.stream(arr).forEach(ints -> {
    System.out.println(Arrays.stream(ints)
            .mapToObj(String::valueOf)
            .reduce((a, b) ->
                    counter.get() % 2 == 0 ? a + " " + b : b + " " + a).get());
    counter.incrementAndGet();
});

此代码使用流api在数组上迭代。第一个流遍历单层数组，第二个流遍历它们的元素，然后形成一个字符串。此外，根据计数器值，项目从左到右或从右到左进行组合。

你不能直接倒过来。但可以使用循环并反转可选行：

void reverseArray() {
    Integer[][] arr = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12},
            {13, 14, 15, 16},
            {17, 18, 19, 20}};
    for (int i = 1; i < arr.length; i += 2) {
        Collections.reverse(Arrays.asList(arr[i]));
    }
}

如果我有一个[5][4]大小的二维数组，我可以在第一行按顺序打印，第二行按相反顺序打印，第三行按顺序打印吗。。。等等。
您不清楚如何使用输出，但这里有一个简单的方法：

public static void main(String[] args) {
    int[][] values = new int[][]{
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12},
            {13, 14, 15, 16}
    };

    for (int r = 0; r < values.length; r++) {
        if (r % 2 == 0) {
            // forwards
            for (int c = 0; c < (values[r].length - 1); c++) {
                System.out.print(values[r][c] + " ");
            }
            System.out.println(values[r][values[r].length - 1]);
        } else {
            // backwards
            for (int c = (values[r].length - 1); c > 0; c--) {
                System.out.print(values[r][c] + " ");
            }
            System.out.println(values[r][0]);
        }
    }
}

输出：

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