如何在Java8中初始化二维数组

在Java8版本之前，我们可以使用for循环初始化二维数组，如下所示。如何在JDK1.8中使用lambda表达式执行以下操作

int[][] board = new int[3][3];
int v = 1;
for (int i = 0; i < board.length; i++) {

    for (int j = 0; j < 3; j++) {

        board[i][j] = v;
        v++;
        System.out.println(v);
    }
}
System.out.println(Arrays.deepToString(board));

---

使用

IntStream

。这将创建从

0

包含到

n

独占的连续整数流。因此，对于3x3矩阵，

IntStream

是

0,1,2

。 为外部流中的每个整数制作另一个

IntStream

，从

0

到列数-也是3

不能在流中增加

v

，因为它必须是“有效的最终值”。相反，我们使用方程

board[j][i]=1+（j+m*i）

，这实际上与将board展平为单个数组（1D矩阵）时计算值的索引类似

输出：

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

注意：正是因为streams允许您编写更简洁、功能性更强的编程语法，所以常常会产生相关的性能损失。它强调了“为什么要修复未损坏的？”。对于3x3板，您可能看不出有什么不同。但是，如果你的棋盘大得多，考虑到所有创建的对象和场景后面使用的额外空间，它可能不会证明自己是值得的。有时，一个简单的for循环（特别是在处理数组时）更好

---

请记住，简单性是关键。

我强烈建议您坚持使用

for循环

初始化具有基本值的数组。对于多维数组，我的建议更为强烈

然而，方法如下：

int a = 4;               // Number of outer array elements
int b = 2;               // Number of inner array elements

int[][] board = IntStream
    .range(0, a)                                               // iterate 0..3
    .mapToObj(i -> IntStream.range(0, b)                       // for each iteratoe 0..1
                            .map(j -> 1 + (i + (a + 1) * j))   // calculate the value
                            .toArray())                        // compose the inner array
    .toArray(int[][]::new);                                    // compose the outer array

请注意，可以创建一个基元数组，因为它是一个基元int值元素序列。它的方法是reutrns

int[]

外部数组的组合有点棘手，因为

int[]

不再是一个基本值，而是数组本身。需要使用将

int

映射到对象的方法-然后返回，并且必须使用使用参数转换为数组的方法，因为无法将

object[]

转换为

int[]

---

传递的参数很简单

int[]]：：new

与

i->new int[a][b]

没有什么不同。您可以使用

IntStream

方法

range

和

iterate

的组合：

int width = 4, height = 2;

IntStream.rangeClosed(1, width)
         .mapToObj(column -> IntStream.iterate(column, v -> v + width)
                                      .limit(height)
                                      .toArray())
         .toArray(int[][]::new);

通过对内环使用

iterate

和

rangeClosed（1，width）

而不是

range（0，width）

我们可以稍微简化计算。使用

toArray

无需自己创建和修改阵列，并可启用并行处理

---

重要的是要正确地使用流，使它们不仅仅是寻找循环。仅仅用一个

范围（0，x）替换循环。forEach（…）

修改局部变量并不真正“使用流”，因此最好坚持使用for循环。

下面是一个类似于“嵌套循环”的流解决方案

获取从0到N的数字序列（上限独占->N=board.length

获取从0到M的数字序列（上限独占->M=board[i]。长度

对于每对（i，j），使用func（i+j*步骤+1）设置板[i][j]的值，其中步骤定义为5

int[][]板的输出=新int[4][2]

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

int[][]板的输出=新int[4][3]

[1,6,11]，[2,7,12]，[3,8,13]，[4,9,14]]

---

int[]]board=IntStream.range（0,3）.mapToObj（i->IntStream.range（0,3）.map（j->i*3+j+1.toArray（））.toArray（int[]]：：new）；

谢谢@shmosel，我想要一个像下面这样的数组[[1,6]，[2,7]，[3,8]，[4,9]]传统的

for

循环具有更好的可读性和效率，尤其是在处理基元类型时。除非另有要求，否则我建议使用传统的

for

循环。

5

是故意丢失还是忘记了？您的循环不会产生这种情况。谢谢。我想要像[[1,6]、[2,7]、[3,8]、[4,9]]@sc1234第5行怎么样？您在序列中跳过了第5行。您需要生成矩阵

4 x 2

（4行，每行2列）。您指定板为

3 x 3

。这意味着您有3行3列。您的预期输出与您提供给我们使用的输入不一致。@sc1234已进行编辑

int a = 4;               // Number of outer array elements
int b = 2;               // Number of inner array elements

int[][] board = IntStream
    .range(0, a)                                               // iterate 0..3
    .mapToObj(i -> IntStream.range(0, b)                       // for each iteratoe 0..1
                            .map(j -> 1 + (i + (a + 1) * j))   // calculate the value
                            .toArray())                        // compose the inner array
    .toArray(int[][]::new);                                    // compose the outer array

int width = 4, height = 2;

IntStream.rangeClosed(1, width)
         .mapToObj(column -> IntStream.iterate(column, v -> v + width)
                                      .limit(height)
                                      .toArray())
         .toArray(int[][]::new);

int step = 5;

IntStream.range(0, board.length).forEach(i ->
    IntStream.range(0, board[i].length).forEach(j ->
        board[i][j] = i + j * step + 1
    )
);