在Java中展平迭代器的迭代器

在Java中展平迭代器的迭代器。如果输入为[[1,2]，[3[4,5]]，6]，则应返回[1,2,3,4,5,6]。实现hasNext（）和next（）。当内部迭代器列表为空时，请小心。 我认为我的代码不适用于多个级别的内部列表

公共类列表{
int index=0；//保留一个索引以指示当前访问元素的位置
List FlattedList=新建ArrayList（）；//FlattedList
公开名单{
对于（List:List）{//将所有内部列表添加到基础列表中。
FlattedList.addAll（列表）；
}
}
public boolean hasNext（）{//检查索引是否超过列表大小
return flattedList.size（）>index？true:false；
}
public Integer next（）{//返回下一个元素，并递增索引
整数结果=扁平化列表.get（索引）；
索引++；
返回结果；
}
}

在这里，我将为您启动：

public <T> Iterator<T> flatten(final Iterator<Iterator<T>> iterators) {
    if (iterators == null) {
        throw new IllegalArgumentException("iterators can't be null");
    }

    return new Iterator<>() {
        @Override
        public boolean hasNext() {
            throw new UnsupportedOperationException("Not implemented: hasNext");
        }

        @Override
        public T next() {
            throw new UnsupportedOperationException("Not implemented: next");
        }
    };
}

公共迭代器展平（最终迭代器）{
if（迭代器==null）{
抛出新的IllegalArgumentException（“迭代器不能为null”）；
}
返回新的迭代器（）{
@凌驾
公共布尔hasNext（）{
抛出新的UnsupportedOperationException（“未实现：hasNext”）；
}
@凌驾
公共交通工具{
抛出新的UnsupportedOperationException（“未实现：下一步”）；
}
};
}

现在你只要做那烦人的脑力劳动，你就完蛋了

编辑

如果您不习惯这种语法，这里有一个稍微简单一点的：

public <T> Iterator<T> flatten(final Iterator<Iterator<T>> iterators) {
    return new MyFlatteningIterator<>(iterators);
}

public class MyFlatteningIterator<T> implements Iterator<T> {
    private final Iterator<Iterator<T>> iterators;

    public MyFlatteningIterator(final Iterator<Iterator<T>> iterators) {
        if (iterators == null) {
            throw new IllegalArgumentException("iterators can't be null");
        }
        this.iterators = iterators;
    }

    @Override
    public boolean hasNext() {
        throw new UnsupportedOperationException("Not implemented: hasNext");
    }

    @Override
    public T next() {
        throw new UnsupportedOperationException("Not implemented: next");
    }
}

公共迭代器展平（最终迭代器）{
返回新的MyFlatingIterator（迭代器）；
}
公共类MyFlatingIterator实现了迭代器{
私有最终迭代器；
公共MyFlating迭代器（最终迭代器迭代器）{
if（迭代器==null）{
抛出新的IllegalArgumentException（“迭代器不能为null”）；
}
this.iterators=迭代器；
}
@凌驾
公共布尔hasNext（）{
抛出新的UnsupportedOperationException（“未实现：hasNext”）；
}
@凌驾
公共交通工具{
抛出新的UnsupportedOperationException（“未实现：下一步”）；
}
}

所以基本上这就像编写一个树的深度优先遍历。该树的叶节点是数字，所有内部节点都建模为迭代器。下面是一些伪代码：

void flatten(Iterator<Object> iterator, List<Integer> flattenedList) {
    for (Object o : iterator)  {
        if (o instanceof Iterator) {
          flatten((Iterator) o, flattenedList);
        } else {
          flattenedList.add((Integer) o);
        }
     }
}

void展平（迭代器迭代器，列表展平列表）{
for（对象o：迭代器）{
if（迭代器的o实例）{
展平（（迭代器）o，展平列表）；
}否则{
展平列表。添加（（整数）o）；
}
}
}

你好，克里斯。现在我在考虑这个问题，因为给定一个可以包含元素、列表和输出的列表是一个迭代器，用于展平嵌套列表。我可以先在构造函数中展平嵌套列表并将其存储在普通列表中吗。随后，next（）和hasNext（）使用一个指向当前元素提取位置的简单计数器从普通列表中取出。为了展平列表，我们使用如下的复合模式算法。您如何看待这种方法？@user3216886说明中清楚地说是“迭代器”而不是“列表”，所以不要局限于列表。另外，问问自己关于内存的问题：如果我有100万个迭代器，每个迭代器迭代100万个项目，那么预展平整个集合真的那么实用吗？那会耗尽记忆吗？有没有一种内存紧张程度较低的方法可以做到这一点？您的函数采用列表（整数）而不是迭代器（泛型类型）的迭代器（Chris的答案应该可以帮助您解决这一问题）。