java - 读取维度未知的数组中的值范围

Question

我正在寻找一种方法来读取未知维度(不是长度)数组中的一系列元素。

客户端可以发送对象的读取请求，并指定读取的范围。输入字符串可能如下所示:例如“1:2:3:2,2:3:1:4”。这意味着他想要读取数组的 [1][2][3][2] 到 [2][3][1][4] 范围内的元素。

为了读取具体元素，我创建了这个函数:

public Object readValue(Object obj,int[] positions ) {
    Object value = null;    //Result
    int objDimension = getDimension(obj); //Dimesion of the array
    System.out.println("Dimension: " + objDimension );
    try {
        Object[] aux = (Object[]) obj;
        for (int i = 0; i < objDimension - 1; i++) {
            int pos = positions[i];
            aux = (Object[]) aux[pos];
        }
        value = aux[positions[objDimension - 1]];
        System.out.println("Result: " + value);
    } catch (ArrayIndexOutOfBoundsException e) {
        // TODO: Send a fault to the client.
        System.out.println("Error: "+e.getMessage());
    }
    return value;
}

public static int getDimension(Object value) {
    Class<?> clazz = value.getClass();
    String className = clazz.getName();
    int dimension = 0;
    for (int i = 0; i < className.length(); i++) {
        if (className.charAt(i) != '[') {
            dimension = i;
            break;
        }
    }
    return dimension;
}


//Example.
public static void main(String[] args) {
    // TODO code application logic here
    TestMultiDimensioNRead test = new TestMultiDimensioNRead();
    Integer[][][][] testSubject = new Integer[5][2][4][];

    testSubject[0][0][2] = new Integer[8];
    testSubject[0][0][0] = new Integer[15];
    testSubject[0][0][1] = new Integer[20];
    testSubject[0][0][3] = new Integer[2];
    testSubject[1][1][2] = new Integer[7];
    testSubject[1][1][2][0] = 80;
    test.readValue(testSubject,new int[]{1, 1, 2, 0});
}

我在想一个好方法可能是计算每个维度长度之间的差异。

如果有人能提出一个好主意，我将非常感激。

提前致谢。

编辑1:这个问题中发布的代码确实读取了未知维度数组中给定位置的值。我的问题是读取给定点之间的所有元素。这在最初的问题中可能并不清楚。

Answer 1

您可以使用递归解决方案:

public class Test {
    private class TestMultiDimensioNRead {
        public Integer readValue(Object testSubject, int[] coordinates) {
            return readValue(testSubject, coordinates, 0);
        }

        private Integer readValue(Object testSubject, int[] coordinates, int which) {
            if (testSubject instanceof Object[]) {
                Object[] subject = (Object[]) testSubject;
                if (coordinates.length > which + 1) {
                    return readValue(subject[coordinates[which]], coordinates, which + 1);
                } else {
                    return (Integer) subject[coordinates[which]];
                }
            } else {
                // Throw some sort of exception?
                return -1;
            }
        }

        public Iterator<Integer> readValues(Object testSubject, int[] coordinates, int count) {
            return readValues(testSubject, coordinates, count, 0);
        }

        private Iterator<Integer> readValues(Object testSubject, int[] coordinates, int count, int level) {
            if (testSubject instanceof Object[]) {
                Object[] subject = (Object[]) testSubject;
                if (coordinates.length > level + 1) {
                    return readValues(subject[coordinates[level]], coordinates, count, level + 1);
                } else {
                    return new Iterator<Integer>() {
                        int i = 0;
                        Integer[] intSubject = (Integer[]) subject;

                        @Override
                        public boolean hasNext() {
                            return i <= count;
                        }

                        @Override
                        public Integer next() {
                            return intSubject[coordinates[level] + (i++)];
                        }
                    };
                }
            } else {
                // Throw some sort of exception?
                return null;
            }
        }

    }

    public void test() {
        TestMultiDimensioNRead test = new TestMultiDimensioNRead();
        Integer[][][][] testSubject = new Integer[5][2][4][];

        testSubject[0][0][2] = new Integer[8];
        testSubject[0][0][0] = new Integer[15];
        testSubject[0][0][1] = new Integer[20];
        testSubject[0][0][3] = new Integer[2];
        testSubject[1][1][2] = new Integer[7];
        testSubject[1][1][2][0] = 80;
        testSubject[1][1][2][1] = 79;
        testSubject[1][1][2][2] = 78;
        Iterator<Integer> them = test.readValues(testSubject, new int[]{1, 1, 2, 0}, 3);
        for (Integer x = them.next(); them.hasNext(); x = them.next()) {
            System.out.println(x);
        }
        System.out.println();

    }

    public static void main(String args[]) {
        try {
            new Test().test();
        } catch (Throwable t) {
            t.printStackTrace(System.err);
        }
    }
}

按预期打印 80。

在健全性检查方面可能还有更多工作要做，但这似乎有效。