用Java中的多维数组填充Arrays.fill

如何在Java中填充多维数组而不使用循环？我试过：

double[][] arr = new double[20][4];
Arrays.fill(arr, 0);

---

这会导致

java.lang.ArrayStoreException:java.lang.Double

这是因为

Double[][]

是一个

Double[]

数组，您无法将

0.0

分配给它（这就像执行

Double[]vector=0.0

）。事实上，Java没有真正的多维数组

double[][] arr = new double[20][4];
Arrays.fill(arr[0], 0);
Arrays.fill(arr[1], 0);
Arrays.fill(arr[2], 0);
Arrays.fill(arr[3], 0);
Arrays.fill(arr[4], 0);
Arrays.fill(arr[5], 0);
Arrays.fill(arr[6], 0);
Arrays.fill(arr[7], 0);
Arrays.fill(arr[8], 0);
Arrays.fill(arr[9], 0);
Arrays.fill(arr[10], 0);
Arrays.fill(arr[11], 0);
Arrays.fill(arr[12], 0);
Arrays.fill(arr[13], 0);
Arrays.fill(arr[14], 0);
Arrays.fill(arr[15], 0);
Arrays.fill(arr[16], 0);
Arrays.fill(arr[17], 0);
Arrays.fill(arr[18], 0);
Arrays.fill(arr[19], 0);

碰巧，

0.0

是Java中double的默认值，因此，当您从

new

获取矩阵时，它实际上已经被零填充了。但是，如果您想在其中填充，比如说，

1.0

，您可以执行以下操作：

我不相信API提供了一种不用循环就能解决这个问题的方法。不过，使用for-each循环就足够简单了

double[][] matrix = new double[20][4];

// Fill each row with 1.0
for (double[] row: matrix)
    Arrays.fill(row, 1.0);

如何在Java中填充多维数组而不使用循环

多维数组只是数组的数组，

fill（…）

不检查数组的类型和传入的值（此责任由开发人员承担）

因此，如果不使用循环，就无法很好地填充多维数组

---

注意到，与C语言或C++语言不同，java数组是对象，多维数组中的所有数组都包含对其他<代码>数组< /Cord>对象的引用。我不是100%确定这一点，但它们很可能分布在内存中，因此不能像C/C++允许的那样只填充连续块而不使用循环。

OP询问如何在不使用循环的情况下解决此问题！出于某种原因，现在流行的做法是避免循环。为什么会这样？可能有一种认识，使用

映射

，

减少

，

过滤

，和朋友，以及像

每个

隐藏循环和减少程序冗余这样的方法是很酷的。这同样适用于真正甜美的Unix管道。或者jQuery代码。没有环，一切看起来都很好

但是Java有

map

方法吗？不完全是这样，但是我们可以定义一个带有

函数

接口和

eval

或

exec

方法的函数。这不太难，是一个很好的锻炼。它可能很昂贵，而且没有在实践中使用

不使用循环的另一种方法是使用尾部递归。是的，这有点傻，没有人会在实践中使用它，但它确实表明，也许，循环在这种情况下是好的。然而，为了展示“又一个无循环示例”并获得乐趣，以下是：

import java.util.Arrays;
public class FillExample {
    private static void fillRowsWithZeros(double[][] a, int rows, int cols) {
        if (rows >= 0) {
            double[] row = new double[cols];
            Arrays.fill(row, 0.0);
            a[rows] = row;
            fillRowsWithZeros(a, rows - 1, cols);
        }
    }

    public static void main(String[] args) {
        double[][] arr = new double[20][4];
        fillRowsWithZeros(arr, arr.length - 1, arr[0].length);
        System.out.println(Arrays.deepToString(arr));
    }
}

---

这并不漂亮，但在回答OP的问题时，没有显式循环。

作为答案的扩展，我找到了这篇文章，但希望填充一个4维数组。 最初的例子只是一个二维数组，但问题是“多维的”。我不想为此发布新问题

可以使用相同的方法，但必须嵌套它们，以便最终得到一维数组

fourDArray = new float[10][10][10][1];
// Fill each row with null
for (float[][][] row: fourDArray)
{
    for (float[][] innerRow: row)
    {
        for (float[] innerInnerRow: innerRow)
        {
        Arrays.fill(innerInnerRow, -1000);
        }
    }
};

---

我们不是有时候都希望有一个

void java.util.Arrays.deepFill（T[]…多维）

。问题始于

objectthreebythree[][]=新对象[3][3]

threeByThree[1]=null和

threeByThree[2][1]=newint[]{42}完全合法。

（如果对象twoDim[]final[]
合法且定义明确……

（使用下面的一个公共方法可以从调用源代码中保留循环。

如果坚持不使用任何循环，请使用递归替换循环和对
Arrays.fill（）
（！）的调用。）

/**用{@code value}填充矩阵{@code m}。
*@return{@code m}的维度。
*如果组件类型为
*在底层的非零长度子阵列的
*不符合{@code value}的类型*/
公共静态整型深度填充（对象[]m，T值）{
类组件；
if（null==m||
null==（组件=m.getClass（）.getComponentType（））
返回0；
int dim=0；
做
dim++；
while（null！=（components=components.getComponentType（））；
填充物（（对象[][]）m，值，dim）；
返回暗淡；
}
/**用{@code value}填充矩阵{@code m}。
*如果组件类型为
*在{@code-dimensions}级别上长度非零的子数组的
*不符合{@code value}的类型*/
公共静态空白填充（对象[]m，T值，int维度）{
如果（空！=m）
填料（m、值、尺寸）；
}
静态空隙填充（对象[]m，T值，int-toGo）{
if（--toGo
公共静态对象[]填充数组（对象[]arr，对象项）{
数组。填充（arr，项）；
返回arr；
}
字符[][]迷宫=新字符[10][10]；
填充数组（迷宫，填充数组（迷宫[0]，“？”）；
对于使用Java 8的（int i=0；i），可以声明和初始化二维数组，而无需使用（显式）循环，如下所示：

int x = 20; // first dimension
int y = 4; // second dimension

double[][] a = IntStream.range(0, x)
                        .mapToObj(i -> new double[y])
                        .toArray(i -> new double[x][]);

这将使用默认值初始化数组（
0.0
在
double
的情况下）

如果要明确定义要使用的填充值，可以添加一个
DoubleStream
：

int x = 20; // first dimension
int y = 4; // second dimension
double v = 5.0; // fill value

double[][] a = IntStream
        .range(0, x)
        .mapToObj(i -> DoubleStream.generate(() -> v).limit(y).toArray())
        .toArray(i -> new double[x][]);

简单地说，java不提供这样的API。
您需要迭代循环，使用fill方法可以用一个循环填充2D数组。

      int row = 5;
      int col = 6;
      int cache[][]=new int[row][col];
      for(int i=0;i<=row;i++){
          Arrays.fill(cache[i]);
      }

int行=5；
int col=6；
int cache[][]=新的int[row][col]；
对于Java8中的（inti=0；i，我们可以使用这种方法

double[]arr=新的双精度[20][4]；
Arrays.stream（arr.forEach）（a->Arrays.fill（a，0））；

我们可以以一种更好、更智能的方式初始化多维数组中的值。
数组。填充仅适用于一维数组

java.util.Array的源代码：

public static void fill(Object[] a, Object val) {
        int i = 0;

        for(int len = a.length; i < len; ++i) {
            a[i] = val;
        }

公共静态空白填充（对象[]a，对象val）{
int i=0；
对于（整数）=
int x = 20; // first dimension
int y = 4; // second dimension
double v = 5.0; // fill value

double[][] a = IntStream
        .range(0, x)
        .mapToObj(i -> DoubleStream.generate(() -> v).limit(y).toArray())
        .toArray(i -> new double[x][]);

      int row = 5;
      int col = 6;
      int cache[][]=new int[row][col];
      for(int i=0;i<=row;i++){
          Arrays.fill(cache[i]);
      }

public static void fill(Object[] a, Object val) {
        int i = 0;

        for(int len = a.length; i < len; ++i) {
            a[i] = val;
        }

for (int i = 0, len = arr.length; i < len; i++)
    Arrays.fill(arr[i], 0);