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 effet, un double[][] est un tableau de double[] que vous ne pouvez pas attribuer 0.0 (cela reviendrait à faire double[] vector = 0.0 ). En fait, Java ne dispose pas de véritables tableaux multidimensionnels.

Il se trouve que, 0.0 est la valeur par défaut pour les doubles en Java, la matrice sera donc déjà remplie de zéros lorsque vous l'obtiendrez à partir de l'application new . Cependant, si vous vouliez le remplir avec, disons, 1.0 vous pourriez faire ce qui suit :

Je ne pense pas que l'API fournisse une méthode pour résoudre ce problème sans utiliser une boucle. Il est cependant assez simple de le faire avec une boucle for-each.

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

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

Answer 2

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

Answer 3

Selon Java 8, nous pouvons utiliser cette méthode.

double[][] arr = new double[20][4];
Arrays.stream(arr).forEach(a -> Arrays.fill(a, 0));

Nous pouvons initialiser une valeur dans un tableau multidimensionnel d'une manière plus agréable et intelligente.

Answer 4

Le PO a demandé comment résoudre ce problème sans boucle ! Pour une raison quelconque, il est à la mode aujourd'hui d'éviter les boucles. Pourquoi ? On s'est probablement rendu compte que l'utilisation de map , reduce , filter et des amis, et des méthodes comme each cachent les boucles, réduisent le verbiage du programme et sont plutôt cool. Il en va de même pour les pipelines Unix vraiment sympas. Ou du code jQuery. Les choses sont tout simplement superbes sans boucles.

Mais est-ce que Java a un map méthode ? Pas vraiment, mais on pourrait en définir une avec une méthode Function avec une interface eval o exec méthode. Ce n'est pas trop difficile et ce serait un bon exercice. Elle pourrait être coûteuse et ne pas être utilisée dans la pratique.

Une autre façon de procéder sans boucle est d'utiliser la récursion de queue. Oui, c'est un peu idiot et personne ne l'utiliserait en pratique non plus, mais cela montre, peut-être, que les boucles sont bien dans ce cas. Néanmoins, juste pour montrer "encore un autre exemple sans boucle" et pour s'amuser, voici :

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

Ce n'est pas beau à voir, mais pour répondre à la question de l'OP, il n'y a pas explicite boucles.

Answer 5

comment remplir un tableau multidimensionnel en Java sans utiliser de boucle ?

Les tableaux multidimensionnels ne sont que des tableaux de tableaux et fill(...) ne vérifie pas le type du tableau et la valeur que vous lui passez (cette responsabilité incombe au développeur).

Ainsi, vous ne pouvez pas remplir un tableau multidimensionnel de manière raisonnable sans utiliser une boucle.

Soyez conscient du fait que, contrairement à des langages comme C ou C++, les tableaux Java sont des objets et que, dans les tableaux multidimensionnels, tous les niveaux, sauf le dernier, contiennent des références à d'autres tableaux. Array objets. Je n'en suis pas sûr à 100%, mais il est fort probable qu'ils soient distribués en mémoire, ce qui fait que vous ne pouvez pas simplement remplir un bloc contigu sans boucle, comme le C/C++ vous le permettrait.