从Java中的多维数组中获取未知数量的维度

Question

在 Java 中是否可以找到具有“先验”未知维数的数组的维数？也就是说，如果不知道多维矩阵的维数，如果可能的话，如何检索它？

Answer 1

有谁知道在 Java 中是否可以获取具有“先验”未知维数的数组的维数？也就是说，如果不知道多维矩阵的维数，如果可能的话，如何检索它？

我不确定我是否正确理解了您要完成的工作。如果您只想知道数组中有多少个元素，Anubian 的答案是正确的。但我的理解是，你想计算给定通用数组的维数。

public class Test {
    public static int getNumberOfDimensions(Class<?> type) {
        if (type.getComponentType() == null) {
            return 0;
        } else {
            return getNumberOfDimensions(type.getComponentType()) + 1;
        }
    }

    public static void main(String[] args) {
        System.out.println(getNumberOfDimensions(int[][][].class)   == 3);
        System.out.println(getNumberOfDimensions(int[][].class)     == 2);
        System.out.println(getNumberOfDimensions(int[][][][].class) == 4);
        System.out.println(getNumberOfDimensions(int.class)         == 0);
    }
}

如果这不是您想要的，我会提示：length 和 dimension 之间存在差异。

---

更新：我认为这与我们被问到的完全无关，但 Nicola 在 cmets 中问我：

这很好用，但是如果在运行时定义了维度的数量（例如，用户必须输入所需的维度数量）呢？如何定义和初始化数组？

解决方案在于一些基于光反射的黑客攻击：

import java.lang.reflect.Array;

public class Test {
    public static Class<?> getArrayType(Class<?> componentType, int dimensions) throws ClassNotFoundException {
        if (dimensions == 0) {
            return componentType;
        }

        String rawName = componentType.getName();
        switch (rawName) {
            case "byte":    rawName = "B"; break;
            case "char":    rawName = "C"; break;
            case "double":  rawName = "D"; break;
            case "float":   rawName = "F"; break;
            case "int":     rawName = "I"; break;
            case "long":    rawName = "J"; break;
            case "short":   rawName = "S"; break;
            case "boolean": rawName = "Z"; break;
            default:
                rawName = "L" + rawName + ";";
                break;
        }

        for (int i = 0; i < dimensions; i++) {
            rawName = "[" + rawName;
        }

        return Class.forName(rawName);
    }

    public static Object createArray(Class<?> componentType, int dimensions, int length) throws NegativeArraySizeException, ClassNotFoundException {
        if (dimensions == 0) {
            return null;
        }

        Object array = Array.newInstance(getArrayType(componentType, dimensions - 1), length);

        for (int i = 0; i < length; i++) {
            Array.set(array, i, createArray(componentType, dimensions - 1, length));
        }

        return array;
    }

    public static void main(String[] args) throws ClassNotFoundException {
        Object object = createArray(Integer.class, 3, 10);
        System.out.println(object.getClass());
    }
}

诀窍是使用给定的组件类型为 N 维数组构造一个类。如果我们知道类名是如何存储在最低级别的，我们就可以做到这一点。其余代码只是一个简单无趣的递归。

Answer 2

假设你的矩阵叫做 m:

可以通过运行得到列数

m.length;

在 Java 中，多维数组实际上是数组的数组。行数是可变的。假设 i 是介于 0 和 m.length-1 之间的整数，您可以这样做：

m[i].length;

获取行中的元素个数。

Answer 3

这里最初的问题是，您不能从以下内容开始说：

int getNumDimensions(int[] array) { ... }

因为如果theArray 实际上是int[][]、int[][][] 等，这将失败。但是Java 中的所有数组都是Object 子类，所以这可以适用于任意数量的维度：

int getNumDimensions(Object array) {zz
    if (array instanceof Object[]) {
        // array has at least 2 dimensions (e.g. int[][])
        return getNumDimensions(((Object[]) array)[0]) + 1;
    }
    if (array.getClass().isArray()) {
        // array is, by process of elimination, one-dimensional
        return 1;
    }
    return 0;
}

编辑：我已经为那些疯狂的百万维数组尝试了非递归解决方案！

int getNumDimensions(Object array) {
    Object tmp = array;
    int nDimensions = 0;
    while (True) {
        if (array instanceof Object[]) {
            // tmp has at least 2 dimensions (e.g. int[][])
            tmp = ((Object[]) array)[0];
        }
        else if (tmp.getClass().isArray()) {
            // tmp is, by process of elimination, one-dimensional
            return nDimensions + 1;
        }
        nDimensions++;
    }
}

Answer 4

我可以建议您通过使用只有一维的数组来解决此问题。假设有 N 个尺寸的维度：

然后您可以将数组的大小定义为：

   int size = S_0*S_1*...*S_N-1;

然后你将初始化它，例如一个整数数组：

int[] array = new int[size];

然后要引用数组中的一项（读取或写入），您有 N 个索引（因为有 N 个维度）：

您现在需要的是一种方法，将这 N 个索引转换为一个可以用作一维数组中索引的单个值，通用公式为：

基本上，这个公式会“跳过”正确数量的先前维度并指向正确的位置。这个公式可以简单地用类似的方法实现

int read(int[] array, int[] indexes);
void write(int[] array, int[] indexes, int values);

为了保持代码的可读性。 您也可以使用泛型类型来实现此技术，因此这些方法可能适用于任何类型。

Answer 5

通过直接查看初始化它的代码或调用其类并检查其反射属性来查看其动态类型。