Question

我是Java的新手，我需要列出一系列列表。我可以在python中完成它，因为列表的元素可以是一个列表，因此在嵌入列表中list[0]将引用一个列表，list[0][0]将引用嵌入列表的zeroeth元素。有没有简单的方法在java中实现这种行为？

Answer 1

所有其他答案在技术上都是正确的，但恕我直言，如果您实施一个粗略的列表列表，您不会在正确的抽象级别处理您的数据。例如，我很确定列表列表在您的业务领域中已经意味着“某些东西”。将这个“东西”封装在另一个对象中，这样你就可以得到一个List＆lt; Something＆gt;而不是难以使用和维护List＆lt; List＆lt; List＆lt; Object＆gt;＆gt;＆gt;。

Answer 2

正如Mario所说，您可能需要进一步抽象出您的数据。但是，以下内容将满足您的需求。

在Java中你会这样：

List<List<List<Object>>> listOfListsOfLists =new ArrayList<List<List<Object>>>();

然后要访问这些项目，您可以使用：

listOfListsOfLists.get(a).get(b).get(c);

或者，迭代一切：

for (List<List<Object>> list2: listOfListsOfLists) {
    for (List<Object> list1: list2) {
        for (Object o: list1) {
            // use `o`
        }
    }
}

Answer 3

由于所有这些答案都让我成了barf，我可以添加你的建议吗

创建数据类型以表达您的数据，同时封装结构的详细信息，或者至少
创建一个包装int []的键类型（但是正确地覆盖equals和hashCode）并使用HashMap代替？无论如何，您的整个三维结构通常很少被填满。

更好的是，您可以封装该地图并使用varargs进行干净访问。

public class NDimensionalArray<V> {
    private final int dimensions;
    private final Map<Key, V> values = new HashMap<Key, V>();

    private NDimensionalArray(int dimensions) {
        this.dimensions = dimensions;
    }

    public V get(int... indices) {
        checkIndices(indices);
        return values.get(new Key(indices));
    }

    public void set(V value, int... indices) {
        checkIndices(indices);
        values.put(new Key(indices), value);
    }

    private void checkIndices(int[] indices) {
        if ( indices.length != dimensions ) {
            throw new IllegalArgumentException();
        }
    }

    private static final class Key {
        private final int[] indices;

        private Key(int[] indices) {
            this.indices = indices;
        }

        @Override
        public int hashCode() {
            return Arrays.hashCode(indices);
        }

        @Override
        public boolean equals(Object obj) {
            return Arrays.equals(indices, ((Key)obj).indices);
        }
    }
}

如果人们有已建立的集合库的例子已经做过这类事情，请告诉我，我会添加链接。

Answer 4

虽然你可以构建一个List＆lt; List＆lt; List＆lt; whatever＆gt;＆gt;＆gt;在Java中，我不禁想知道，你为什么要这样做？并不是说这是你问题的最佳解决方案是不可思议的，但哇，就像为什么？

我想我可以想象像

这样的东西

public class Employee ...
List<Employee> store; // all the employees in a store
List<List<Employee>> city; // all the store lists for a city
List<List<List<Employee>>> nation; // all the store lists for the nation

但你真的想以这种方式处理吗？我不知道，这取决于你需要做什么。

Answer 5

一个综合示例，显示带有集合和泛型的List-of-List（Java 1.5 +）

// declare the list of lists
List<List<String>> listOfListOfStrings = new ArrayList<List<String>>();

// populate
List<String> listOfStrings = new ArrayList<String>(); // one inner list
listOfStrings.add("one-one");
listOfStrings.add("one-two");
listOfListOfStrings.add(listOfStrings);

listOfStrings = new ArrayList<String>(); // and another one
listOfStrings.add("two-one");
listOfStrings.add("two-two");
listOfListOfStrings.add(listOfStrings);

// access
String oneOne = listOfListOfStrings.get(0).get(0);   // first element of first inner list
String twoTwo = listOfListOfStrings.get(1).get(1);   // second element of second inner list

列表清单

5 个答案: