采访：集合迭代器

Question

嗨，伙计们，我把这个作为面试问题来回答，但我遇到了麻烦。我熟悉泛型/集合

问题是：所提供的工作区中包含cocI，它是一个类的开始，该类实现了一个迭代器，可用于迭代集合集合。集合集合被传递到类的构造函数中。迭代器应该首先遍历内容深度。

例如，如果集合集合如下所示：

[0] – [“A”, “B”, “C”] 
[1] – [“D”] 
[2] – [“E”, “F”] 

然后迭代器应按以下顺序返回内容：“A”、“B”、“C”、“D”、“E”、“F”

Q.在cocI中提供hasNext（）和next（）方法的实现

谢谢

import java.util.Collection;
import java.util.Iterator;

public class cocI implements Iterator<Object> {

    private Collection<Collection<Object>> _collOfColl = null;

    public cocI(Collection<Collection<Object>> collofColl) {
        _collOfColl = collofColl;
    }

    public boolean hasNext() {
        // TODO implement this method
        return false;
    }


    public Object next() {
        // TODO implement this method
        return null;
    }


    public void remove() {
        throw new UnsupportedOperationException();
    }

}

Answer 1

几句开场白：

• cocI是一个奇怪的类名；它应该以大写字母开头

解决方案包括外部集合的迭代器和内部集合的迭代器。当内部迭代器的元素用完时，需要为下一个集合用迭代器替换它。然而，考虑到集合可能是空的，升级需要在循环中完成，我将其放入了advanceCollection（）helper中。

import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class cocI<T> implements Iterator<T> {

    private Iterator<Collection<T>> outerIterator;
    private Iterator<T> innerIterator;

    public cocI(Collection<Collection<T>> collofColl) {
        this.outerIterator = collofColl.iterator();
        advanceCollection();
    }

    @Override
    public boolean hasNext() {
        return this.innerIterator != null && this.innerIterator.hasNext();
    }

    @Override
    public T next() {
        if (this.innerIterator == null) {
            throw new NoSuchElementException();
        }
        try {
            return this.innerIterator.next();
        } finally {
            advanceCollection();
        }
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }

    private void advanceCollection() {
        while ((this.innerIterator == null || !this.innerIterator.hasNext())
               && this.outerIterator.hasNext()) {
            this.innerIterator = this.outerIterator.next().iterator();
        }
    }

}

我使用了一段稍微有点棘手的代码：

    try {
        return this.innerIterator.next();
    } finally {
        advanceCollection();
    }

大致相当于：

    T result = this.innerIterator.next();
    advanceCollection();
    return result;

Answer 2

您只需在集合集合中跟踪当前集合的迭代器。hasnext（）方法是一个棘手的部分，它将执行以下两个操作之一：如果当前迭代器有更多元素，则返回true；如果在找到包含元素的集合之前不进行搜索，则返回true。如果我们耗尽所有集合，则返回false。

public class Cocl implements Iterator<Object> {

    private Collection<Collection<Object>> _collOfColl = null;
    private final Iterator<Collection<Object>> coClIterator;
    private Iterator<Object> currentColIterator;

    public Cocl(Collection<Collection<Object>> collofColl) {
        _collOfColl = collofColl;
        coClIterator = collofColl.iterator();
        if (coClIterator.hasNext()) {
            currentColIterator = coClIterator.next().iterator();
        }
    }

    public boolean hasNext() {
        if (currentColIterator == null) {
            return false;
        }
        if (!currentColIterator.hasNext()) {
            while (coClIterator.hasNext()) {
                currentColIterator = coClIterator.next().iterator();
                if (currentColIterator.hasNext()) {
                    return true;
                }
            }
            return false;
        } else {
            return true;
        }
    }

    public Object next() {
        if (hasNext()) {
            return currentColIterator.next();
        }
        throw new NoSuchElementException();
    }


    public void remove() {
        throw new UnsupportedOperationException();
    }

    public static void main(String[] args) {
        Collection<Object> one = Arrays.asList((Object) "A", (Object) "B", (Object) "C");
        Collection<Object> two = Arrays.asList((Object) "D", (Object) "E");
        Cocl cocl = new Cocl(Arrays.asList(one, two));
        while (cocl.hasNext()) {
            Object a = cocl.next();
            System.out.println(a);
        }
    }

}