Можно ли динамически построить многомерный массив в 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 будет двумерным массивом, эквивалентным:

String[2][4] arr1;

Как насчет этого: что если мы не узнаем размеры этого массива до времени выполнения?

Редактировать: если это поможет (я уверен, что это будет ...), мы пытаемся проанализировать массив неизвестных измерений из строки вида

[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 s.

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 [] позволит вам сделать это, поскольку сами вложенные массивы также считаются объектами и поэтому вписываются в систему типов.

Если вложение является полностью регулярным, вы можете выгрузить эту регулярность и создать соответствующий многомерный массив, используя 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

В качестве дальнейшего замечания, что если мы попробуем что-то вроде этого:

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 5

Хорошо, если вы не уверены в размерах массива, следующий метод не будет работать.Однако, если вы знаете размеры, не используйте отражение.Выполните следующие действия:

Вы можете динамически создавать 2d-массивы гораздо проще, чем это.

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

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

Это будет динамически создавать массив x by y 2d.

Answer 6

Итак, я наткнулся на этот вопрос с кодом для извлечения коэффициентов из полинома с переменным числом переменных. Таким образом, пользователь может хотите массив коэффициентов для многочлена от двух переменных 3 x^2 + 2 x y или он может быть одним с тремя переменными. В идеале вам нужен многомерный массив, который пользователь может легко запросить, чтобы можно было привести его к Целое число [], Целое число [] [] и т. Д.

Это в основном использует ту же технику, что и ответ jdmichal, используя метод Array.newInstance(obj.getClass(), size). Для многомерных массивов 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));
    }
}

Answer 7

Эффективный элемент 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]], как и ожидалось.

Вот демоверсия полного запуска , которая также добавляет регулярное выражение в микс, чтобы устранить пробелы.

Я позволю вам разобраться с другими сценариями.