Java8中层次结构上的单次迭代

如何在不同对象的层次结构上实现单循环迭代

（我使用了for循环，但它们表示网格的不同区域——我几乎无法跟踪用于定位的所有值。使用单个循环将大大简化事情。）

这个对象的层次结构就是我所拥有的

class Hierarchical < PT extends Hierarchical<?,?,?>,T,CT extends Hierarchical< ?, ?, ? >>{
    ObservableList< Hierarchical > children;  //Zero or more objects..
}

class Seed   extends Hierarchical { /* never has children-objects */ }
class Tree   extends Hierarchical { ... }
class Planet extends Hierarchical { ... }

class hierarchy>{
ObservableList子对象；//零个或多个对象。。
}
类种子扩展层次结构{/*从不具有子对象*/}
类树扩展了层次结构{…}
类Planet扩展了层次结构{…}

编辑：行星实例中的子对象是树，包含种子的树也是如此

…这就是我想做的：

Planet p = new Planet(); //trees/seeds are instantiated internally.
Iterator< ? > itr = p.getChildren().iterator();
while ( itr.hasNext() ) {
    Object obj = itr.next();
    if ( obj instanceof Planet ){ /* cast to Planet & do stuff */ }
    if ( obj instanceof Tree   ){ /* cast to Tree   & do stuff */ }
    if ( obj instanceof Seed   ){ /* cast to Seed   & do stuff */ }
}

行星p=新行星（）//树/种子在内部实例化。 迭代器<？>itr=p.getChildren（）.iterator（）； while（itr.hasNext（））{ Object obj=itr.next（）； 如果（行星的obj实例）{/*cast to Planet&do stuff*/} if（obj instanceof Tree）{/*cast to Tree&do stuff*/} if（obj instanceof Seed）{/*cast to Seed&do stuff*/} } 很明显，答案在于迭代器

Iterator<？>itr=p.getChildren（）.iterator（）；

但是如何实现呢？似乎每一个层级都需要保留其子级的位置，以防其子级开始在其子级之间循环。时间太长了，我不再熟悉设计模式和java的集合(

我会注意到，我在尝试使用

Iteratoritr=p.getChildren（）.Iterator（）；

时出错，因为p是Planet类型

---

编辑：这需要是“最后一个深度”（…或FIFO？）。循环是为了简化UI的生成，因此顺序很重要。

如果我理解正确，您希望能够访问对象图中的每个对象，并对每个对象执行操作吗

当每个对象实现一个公共接口时，就像您的一样，这只是使用递归来解决的。您唯一的决定是要执行深度优先递归还是广度优先递归

对于深度优先，您可能希望

public void visit(Hierarchical h) {
    // do something with h
    Iterator<Hierarchical> children = h.getChildren();
    while(children.hasNext()) {
        visit(children.next());
    }
}

公共无效访问（分层h）{
//用h做点什么
迭代器children=h.getChildren（）；
while（children.hasNext（））{
访问（children.next（））；
}
}

似乎每一个层级都需要保持一个 当其子对象开始循环时，其子对象的位置 通过他们的孩子

以这种方式使用递归，您不需要跟踪任何“位置”-当您再次调用该方法时，迭代器的状态保持在堆栈上，因此当堆栈展开时，当您到达“种子”时，您将把堆栈回滚一个级别，并调用迭代器的下一次迭代

对于广度优先，您需要首先处理整个节点，边处理边收集分支。处理完所有子节点后，您需要开始收集分支

public void visit(Hierarchical h) {
    List<Hierarchical> branches = new LinkedList<>();
    Iterator<Hierarchical> children = h.getChildren();

    while(children.hasNext()) {
        Hierarchical h = children.next();
        // do something with h
        if(h.hasChildren()) {
            branches.add(h);
        }
    }

    for(Hierarchical branch : branches) {
        visit(branch);
    }
}

公共无效访问（分层h）{
列表分支=新建LinkedList（）；
迭代器children=h.getChildren（）；
while（children.hasNext（））{
层次h=子级。下一步（）；
//用h做点什么
if（h.haschilds（））{
添加（h）；
}
}
用于（分层分支：分支）{
参观（分会）；
}
}

所以您想要一个遍历特定节点的整个子层次结构的迭代器？您想要深度优先还是呼吸优先？谢谢Andreas。我不认为它是“第一个”或“最后一个”，而是“遇到时”。我想Ramsay已经用递归给出了一个不错的答案。我不能说我喜欢这个结果，但它应该会起作用。深度优先对UI不起作用。很抱歉，我没有解释，这是迭代多层变量以显示在网格上。顺序很重要。（在原始帖子中添加了编辑。）是的，我知道你现在在做什么！稍微调整一下，这应该很好。我很快就会发布我的更改。谢谢。=D