Arrays.fill avec un tableau multidimensionnel en Java

Question

Comment remplir un tableau multidimensionnel en Java sans utiliser de boucle ? J'ai essayé :

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

Il en résulte java.lang.ArrayStoreException: java.lang.Double

Answer 1

En complément de la réponse, j'ai trouvé cet article mais je cherchais à remplir un tableau à 4 dimensions. L'exemple original n'est qu'un tableau à deux dimensions, mais la question dit "multidimensionnel". Je ne voulais pas poster une nouvelle question pour cela...

Vous pouvez utiliser la même méthode, mais vous devez les imbriquer de manière à obtenir un tableau unidimensionnel.

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);
        }
    }
};

Answer 2

Arrays.fill fonctionne avec un tableau à une seule dimension, donc pour remplir un tableau à deux dimensions nous pouvons faire ce qui suit

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

Answer 3

N'avons-nous pas tous parfois souhaité qu'il y ait un
<T>void java.util.Arrays.deepFill(T[]…multiDimensional) . Les problèmes commencent par
Object threeByThree[][] = new Object[3][3];
threeByThree[1] = null; et
threeByThree[2][1] = new int[]{42}; étant parfaitement légal.
(Si seulement Object twoDim[]final[] était légal et bien défini )
(L'utilisation de l'une des méthodes publiques ci-dessous permet de conserver les boucles du code source appelant.
Si vous insistez pour ne pas utiliser de boucles du tout, remplacez les boucles et l'appel à la fonction Arrays.fill() ( !) en utilisant la récursion).

/** Fills matrix {@code m} with {@code value}.
 * @return {@code m}'s dimensionality.
 * @throws java.lang.ArrayStoreException if the component type
 *  of a subarray of non-zero length at the bottom level
 *  doesn't agree with {@code value}'s type. */
public static <T>int deepFill(Object[] m, T value) {
    Class<?> components; 
    if (null == m ||
        null == (components = m.getClass().getComponentType()))
        return 0;
    int dim = 0;
    do
        dim++;
    while (null != (components = components.getComponentType()));
    filler((Object[][])m, value, dim);
    return dim;
}
/** Fills matrix {@code m} with {@code value}.
 * @throws java.lang.ArrayStoreException if the component type
 *  of a subarray of non-zero length at level {@code dimensions}
 *  doesn't agree with {@code value}'s type. */
public static <T>void fill(Object[] m, T value, int dimensions) {
    if (null != m)
        filler(m, value, dimensions);
}

static <T>void filler(Object[] m, T value, int toGo) {
    if (--toGo <= 0)
        java.util.Arrays.fill(m, value);
    else
        for (Object[] subArray : (Object[][])m)
            if (null != subArray)
                filler(subArray, value, toGo);
}

Answer 4

Avec Java 8, vous pouvez déclarer et initialiser un tableau à deux dimensions sans utiliser de boucle (explicite) comme suit :

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][]);

Ceci initialisera les tableaux avec des valeurs par défaut ( 0.0 dans le cas de double ).

Dans le cas où vous souhaitez définir explicitement la valeur de remplissage à utiliser, vous pouvez ajouter dans un champ 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][]);

Answer 5

Arrays.fill ne fonctionne qu'avec un tableau unidimensionnel

Source de java.util.Arrays :

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

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

Utiliser ses propres boucles pour le tableau d'initialisation