是否可以在Java中动态构建多维数组？

Question

假设我们有Java代码：

Object arr = Array.newInstance(Array.class, 5);

那会跑吗？ 进一步说明，如果我们尝试这样的事情怎么办：

Object arr1 = Array.newInstance(Array.class, 2);
Object arr2 = Array.newInstance(String.class, 4);
Object arr3 = Array.newInstance(String.class, 4);
Array.set(arr1, 0, arr2);
Array.set(arr1, 1, arr3);

那么arr1将是一个等效于2D的2D数组：

String[2][4] arr1;

怎么样：如果我们直到运行时才知道该数组的维数怎么办？

编辑：如果这有帮助（我确定会...），我们正在尝试从形式为String的字符串解析未知维度的数组

[value1, value2, ...]

要么

[ [value11, value12, ...] [value21, value22, ...] ...]

等等

Edit2：如果有人像我这样愚蠢的人尝试使用此垃圾，则此版本至少可以编译并运行。 逻辑是否合理完全是另一个问题。

Object arr1 = Array.newInstance(Object.class, x);
Object arr11 = Array.newInstance(Object.class, y);
Object arr12 = Array.newInstance(Object.class, y);
...
Object arr1x = Array.newInstance(Object.class, y);
Array.set(arr1, 0, arr11);
Array.set(arr1, 1, arr12);
...
Array.set(arr1, x-1, arr1x);

等等。 它只是一个巨大的嵌套对象数组

Answer 1

实际上可以在Java中完成。 （我必须说我有些惊讶。）

免责声明； 除了解决这个问题，我再也不想在其他任何地方看到此代码了。 我强烈建议您使用List 。

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


    }
}

示例输出：

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]]]

Answer 2

在Java中，数组是类型安全的-适用于简单数组和“多维”数组-即数组的数组。

如果嵌套深度在运行时是可变的，那么最好的办法是使用一个与已知的最小嵌套深度相对应的数组（大概为1）。此数组中的元素要么是简单元素，要么是进一步嵌套是必需的，另一个数组。 Object []数组将允许您执行此操作，因为嵌套数组本身也被视为Object，因此适合类型系统。

如果嵌套是完全规则的，则可以使用Array.newInstance(String.class, dimension1, dimension2, ...)抢占此规则并创建适当的多维数组，如果嵌套是不规则的，则使用嵌套更好列表，允许“锯齿状”的结构和动态调整大小。 在泛型的范围内，您可能会有锯齿状的结构。 如果结构参差不齐，则不能使用泛型，因为某些元素可能是简单的项目，而其他元素可能是进一步嵌套的列表。

Answer 3

因此，您可以将多个维度传递给Array.newInstance ，但这会为每个维度强制固定长度。 如果可以，您可以使用以下方法：

// 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]

另一个选择是从上开始建立它们，使用数组的上一个级别的getClass作为下一个级别的输入。 以下代码运行并生成节点定义的锯齿状数组：

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("]");
    }
}

Answer 4

好的，如果不确定数组的维数，则以下方法将不起作用。 但是，如果您知道尺寸，请不要使用反射。 请执行下列操作：

您可以轻松地动态构建2d数组。

int x = //some value
int y = //some other value

String[][] arr = new String[x][y];

这将“动态”创建一个x y 2d数组。

Answer 5

进一步说明，如果我们尝试这样的事情怎么办：

 Object arr1 = Array.newInstance(Array.class, 2); Object arr2 = Array.newInstance(String.class, 4); Object arr3 = Array.newInstance(String.class, 4); Array.set(arr1, 0, arr2); ... 

不，您不能像这样设置String[]值。 你碰到

Exception in thread "main" java.lang.IllegalArgumentException: array element type mismatch
at java.lang.reflect.Array.set(Native Method)
at Test.main(Test.java:12)

Answer 6

有效的Java项目＃（ 我不记得了 ）：知道并使用这些库。

您可以使用List并使用toArray方法：

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

要将其转换为数组，可以使用：

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

诀窍是，声明外部数组以容纳String[] （字符串数组），后者又可以使用另一个List<String>动态创建，或者，如果您使用String.split方法解析字符串，则可以。

演示版

着重于动态创建数组而不是在解析中，这是一个与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()][]);

那里。 现在您的result是一个二维动态创建的数组，其中包含： [[1], [2, 3], [4, 5, 6, 7], [8, 9, 10, 11, 12, 13]] 。

这是一个完整的正在运行的演示 ，它还会在混合中添加更多正则表达式，以消除空格。

我让您处理其他情况。

Answer 7

因此，我遇到了用代码从具有可变数量变量的多项式中提取系数的代码。 因此，用户可能想要一个包含两个变量3 x^2 + 2 xy的多项式的系数数组，或者可能是带有三个变量的一个。 理想情况下，您需要用户可以轻松查询的多维数组，以便可以将其转换为Integer []，Integer [] []等。

基本上，使用Array.newInstance(obj.getClass(), size)方法使用与jdmichal的答案相同的技术。 对于多维数组，obj可以是一维数组。

具有随机创建的元素的示例代码

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

public class MultiDimArray {
    static Random rand = new Random();

    /**
     * Create an multi-dimensional array 
     * @param depth number of dimensions
     * @return
     */
    static Object buildArray(int depth) {
        if(depth ==1) { // For 1D case just use a normal array
            int size = rand.nextInt(3)+1;
            Integer[] res = new Integer[size];
            for(int i=0;i<size;++i) {
                res[i] = new Integer(i);
            }
            return res;
        }
        // 2 or more dimensions, using recursion 
        int size = rand.nextInt(3)+1;
        // Need to get first items so can find its class
        Object ele0 = buildArray(depth-1);
        // create array of correct type
        Object res = Array.newInstance(ele0.getClass(), size);
        Array.set(res, 0, ele0);
        for(int i=1;i<size;++i) {
            Array.set(res, i, buildArray(depth-1));
        }
        return res;
    }

    public static void main(String[] args) {
        Integer[] oneD = (Integer[])  buildArray(1);
        System.out.println(Arrays.deepToString(oneD));

        Integer[][] twoD = (Integer[][])  buildArray(2);
        System.out.println(Arrays.deepToString(twoD));

        Integer[][][] threeD = (Integer[][][])  buildArray(3);
        System.out.println(Arrays.deepToString(threeD));
    }
}