Question

我有一个像这样的列表 - [[1, 2, 3], [4, 5, 6, [1, 2, 3]]]

下面是我的代码 -

    List<Object> inner1=new ArrayList<Object>();
    inner1.add(1);
    inner1.add(2);
    inner1.add(3);

    List<Object> inner2=new ArrayList<Object>();
    inner2.add(4);
    inner2.add(5);
    inner2.add(6);
    inner2.add(inner1);

    List<Object> outer=new ArrayList<Object>();
    outer.add(inner1);
    outer.add(inner2);

    System.out.println(outer);


    for(List<Object> list:(List<List<Object>>)outer){   //compile fail
        for(Object innerData:(List<Object>)list){
             if (innerData instanceof List) {
                for(Integer data: (List<Integer>)innerData){
                    System.out.println(data);
                }

            }else{
                System.out.println(innerData);
            }

        }
    }

为什么这个编译在迭代外部列表时失败。

我知道外部的所有对象都是List<Object>所以这是List<List<Object>>

在List<List<Object>>结果中转换外部是编译失败。

如果这不是预期的结果，那么这应该是ClassCastException而不是编译失败？

Answer 1

outer不是List<List<Object>>，所以你不能这样做。

您应该检查外部列表的每个元素，看它是否是列表本身。

for(Object obj : outer) {
    if (obj instanceof List) {
        List list = (List)obj;
        for(Object innerData: list) {
            if (innerData instanceof List) {
                for (Object obj2 : (List)innerData) {
                    if (obj2 instanceof Integer) {
                        Integer data = (Integer) obj2;
                        ...

编辑：

如果外部列表只能包含List元素，则可以通过将outer的类型更改为List<List<Object>>来简化代码。

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

然后你会

for(List<Object> list : outer) {
    for(Object innerData: list) {
        if (innerData instanceof List) {
            for (Object obj2 : (List)innerData) {
                if (obj2 instanceof Integer) {
                    Integer data = (Integer) obj2;
                    ...

Answer 2

编译错误，因为您的外部类型List<Object>无法转换为List<List<Object>>。

您的代码应为：

for (Object list : outer) {  
    if (list instanceof List) {
        for (Object innerData : (List<Object>) list) {
            if (innerData instanceof List) {
                for (Integer data : (List<Integer>) innerData) {
                    System.out.println(data);
                }

            } else {
                System.out.println(innerData);
            }

        }
    }
}

Answer 3

制作outer类型的List<List<Object>>，您根本不需要投射。

Answer 4

将第一个for循环更改为：

for (List<Object> list : (List<List<Object>>) (List) outer) {

虽然List<Object>当然可以包含List<Object>类型的元素，但在类型系统的约束范围内，您不能将List<Object>强制转换为List<List<Object>>

因为，您实际上可以在列表中添加其他内容，例如String或Integer。如果你然后尝试迭代它就好像它是List<List<Object>>一样，你会得到一些非常奇怪的结果（因为你不能施展Integer或String到List<Object>）

如果您100％确定您的列表外部并不包含任何不是List<Object>的内容，那么您可以告诉Java以这样的方式对待它我在上面描述过。

但你应该意识到Java不是LISP或其他一些基于列表的大量函数式语言。

您正在做的是一种非常不正确的Java数据建模方式。如果你不需要静态输入（以及你所有的演员阵容并将事情视为Object，那就是你正在做的事情）那么你就不应该使用Java作为一种语言;选择另一种更适合您的问题领域的语言！

Answer 5

Outer未定义为List＆gt;。

像这样使用它 -

for(Object list : outer){
    List<Object> o = (List<Object> list);
    // Remaining logic
}

Answer 6

for循环中的变化，

var countSprites = 0
enumerateChildNodesWithName(""spriteToTrack""){node,_ in
     countSprites++
     /* If you want to manipulate this node or  remove it....but dont do it in this loop! 
     let tmpNode = node as! SKSpriteNode // Must be the same as mySprite
     */
}

println("I have \(countSprites ) sprites with name spriteToTrack")

<强>输出

public static void main(String[] args) {
        List<Object> inner1 = new ArrayList<Object>();
        inner1.add(1);
        inner1.add(2);
        inner1.add(3);

        List<Object> inner2 = new ArrayList<Object>();
        inner2.add(4);
        inner2.add(5);
        inner2.add(6);
        inner2.add(inner1);

        List<Object> outer = new ArrayList<Object>();
        outer.add(inner1);
        outer.add(inner2);

        System.out.println(outer);

        for (Object list : outer) {
            if (list instanceof List) {
                for (Object innerData : (List<Object>) list) {
                    if (innerData instanceof List) {
                        for (Integer data : (List<Integer>) innerData) {
                            System.out.println(data);
                        }

                    } else {
                        System.out.println(innerData);
                    }

                }
            }
        }
    }

Answer 7

定义如下方法：

static void printFlat(Object object) {
    if (object instanceof List<?>)
        for (Object element : (List<?>)object)
            printFlat(element);
    else
        System.out.println(object);
}

和

    printFlat(outer);

在迭代列表

7 个答案: