Est-il possible de créer dynamiquement un tableau multidimensionnel en Java?

Il est possible de le faire en java. (Je suis un peu surpris, je dois dire.)

Avertissement; je ne veux plus jamais voir ce code n'importe où ailleurs que comme une réponse à cette question. Je vous encourage fortement à utiliser Lists.

import java.lang.reflect.Array;
import java.util.*;
public class Test {
public static int[] tail(int[] arr) {
return Arrays.copyOfRange(arr, 1, arr.length);
}
public static void setValue(Object array, String value, int... indecies) {
if (indecies.length == 1)
((String[]) array)[indecies[0]] = value;
else
setValue(Array.get(array, indecies[0]), value, tail(indecies));
}
public static void fillWithSomeValues(Object array, String v, int... sizes) {
for (int i = 0; i < sizes[0]; i++)
if (sizes.length == 1)
((String[]) array)[i] = v + i;
else
fillWithSomeValues(Array.get(array, i), v + i, tail(sizes));
}
public static void main(String[] args) {
//Randomly choose number of dimensions (1, 2 or 3) at runtime.
Random r = new Random();
int dims = 1 + r.nextInt(3);
//Randomly choose array lengths (1, 2 or 3) at runtime.
int[] sizes = new int[dims];
for (int i = 0; i < sizes.length; i++)
sizes[i] = 1 + r.nextInt(3);
//Create array
System.out.println("Creating array with dimensions /sizes: " +
Arrays.toString(sizes).replaceAll(", ", "]["));
Object multiDimArray = Array.newInstance(String.class, sizes);
//Fill with some 
fillWithSomeValues(multiDimArray, "pos ", sizes);
System.out.println(Arrays.deepToString((Object[]) multiDimArray));
}
}

Exemple De Sortie:

Creating array with dimensions / sizes: [2][3][2]
[[[pos 000, pos 001], [pos 010, pos 011], [pos 020, pos 021]],
[[pos 100, pos 101], [pos 110, pos 111], [pos 120, pos 121]]]

De sorte que vous pouvez passer plusieurs dimensions à Array.newInstance, mais que les forces d'une longueur fixe pour chaque dimension. Si c'est OK, vous pouvez utiliser ceci:

//We already know from scanning the input that we need a 2 x 4 array.
//Obviously this array would be created some other way. Probably through
//a List.toArray operation.
final int[] dimensions = new int[2];
dimensions[0] = 2;
dimensions[1] = 4;
//Create the array, giving the dimensions as the second input.
Object array = Array.newInstance(String.class, dimensions);
//At this point, array is a String[2][4].
//It looks like this, when the first dimension is output:
//[[Ljava.lang.String;@3e25a5, [Ljava.lang.String;@19821f]
//
//The second dimensions look like this:
//[null, null, null, null]

L'autre option serait de les construire à partir du bas, à l'aide de getClass sur le niveau précédent de tableau que les données d'entrée pour le niveau suivant. Le code suivant s'exécute et produit un tableau en escalier telle que définie par les nœuds:

import java.lang.reflect.Array;
public class DynamicArrayTest
{
private static class Node
{
public java.util.List<Node> children = new java.util.LinkedList<Node>();
public int length = 0;
}
public static void main(String[] args)
{
Node node1 = new Node();
node1.length = 1;
Node node2 = new Node();
node2.length = 2;
Node node3 = new Node();
node3.length = 3;
Node node4 = new Node();
node4.children.add(node1);
node4.children.add(node2);
Node node5 = new Node();
node5.children.add(node3);
Node node6 = new Node();
node6.children.add(node4);
node6.children.add(node5);
Object array = createArray(String.class, node6);
outputArray(array); System.out.println();
}
private static Object createArray(Class<?> type, Node root)
{
if (root.length != 0)
{
return Array.newInstance(type, root.length);
}
else
{
java.util.List<Object> children = new java.util.ArrayList<Object>(root.children.size());
for(Node child : root.children)
{
children.add(createArray(type, child));
}
Object array = Array.newInstance(children.get(0).getClass(), children.size());
for(int i = 0; i < Array.getLength(array); ++i)
{
Array.set(array, i, children.get(i));
}
return array;
}
}
private static void outputArray(Object array)
{
System.out.print("[ ");
for(int i = 0; i < Array.getLength(array); ++i)
{
Object element = Array.get(array, i);
if (element != null && element.getClass().isArray())
outputArray(element);
else
System.out.print(element);
System.out.print(", ");
}
System.out.print("]");
}
}

Ok, si vous n'êtes pas sûr des dimensions de la matrice, la méthode suivante ne fonctionnera pas. Toutefois, si vous connaissez les dimensions, ne pas utiliser de réflexion. Procédez de la manière suivante:

Vous pouvez créer dynamiquement des tableaux 2d beaucoup plus facile que cela.

int x = //some value
int y = //some other value
String[][] arr = new String[x][y];

Ce sera "dynamiquement" créer un x par y tableau 2d.

Efficace Java item # (je ne me souviens pas ) : Connaître et utiliser les bibliothèques.

Vous pouvez utiliser un List et l'utilisation de la toArray méthode:

List<String[]> twoDimension = new ArrayList<String[]>();

Pour le convertir en un tableau, vous devez utiliser:

String [][] theArray = twoDimension.toArray( new String[twoDimension.size()][] );

Le truc, c'est, à l'extérieur tableau est déclaré à tenir String[] ( tableaux de chaîne ) qui à son tour peut être créé dynamiquement avec un autre List<String> ou, si vous êtes l'analyse de chaînes avec la String.split méthode.

Démo

En se concentrant sur la dynamique de la création de la table et pas dans l'analyse, voici un exemple sur la façon dont cela fonctionne est utilisé en conjonction avec String.split

//and array which contains N elements of M size
String input = "[[1],[2,3],[4,5,6,7],[8,9,10,11,12,13]]";
//Declare your dynamic array
List<String[]> multiDimArray = new ArrayList<String[]>();
//split where ],[ is found, just ignore the leading [[ and the trailing ]]
String [] parts = input.replaceAll("\\[\\[|\\]\\]","") 
.split("\\],\\[");
//now split by comma and add it to the list
for( String s : parts ){
multiDimArray.add(  s.split(",") ) ;
}
String [][] result = multiDimArray.toArray( new String[multiDimArray.size()][]);

Là. Maintenant, votre result est un deux dimensions de créer dynamiquement un tableau contenant : [[1], [2, 3], [4, 5, 6, 7], [8, 9, 10, 11, 12, 13]] comme prévu.

Voici un l'exécution complète de la démo, qui ajoute également plus de regexp pour le mélange, afin d'éliminer les espaces blancs.

Je vous laisse gérer les autres scénarios.