在Java中是否有可能合并迭代器？我有两个迭代器，想要将它们组合/合并，以便可以在同一个循环中遍历它们的元素，而不是分别迭代两次。这可行吗？
请注意，这两个列表中的元素数量可能不同，因此一次循环遍历两个列表不是解决方案。
Iterator<User> pUsers = userService.getPrimaryUsersInGroup(group.getId());
Iterator<User> sUsers = userService.getSecondaryUsersInGroup(group.getId());
while(pUsers.hasNext()) {
User user = pUsers.next();
.....
}
while(sUsers.hasNext()) {
User user = sUsers.next();
.....
}
此外，Apache Commons Collection 还有多个用于操作迭代器的类，例如 IteratorChain，该类可以包装多个迭代器。
您可以创建自己的Iterator接口实现，以便迭代迭代器：
public class IteratorOfIterators implements Iterator {
private final List<Iterator> iterators;
public IteratorOfIterators(List<Iterator> iterators) {
this.iterators = iterators;
}
public IteratorOfIterators(Iterator... iterators) {
this.iterators = Arrays.asList(iterators);
}
public boolean hasNext() { /* implementation */ }
public Object next() { /* implementation */ }
public void remove() { /* implementation */ }
}
(出于简洁考虑，我没有将泛型添加到迭代器中。) 实现并不太难，但也不是最简单的，你需要跟踪当前正在迭代的Iterator，并在调用next()时尽可能地遍历迭代器，直到找到返回true的hasNext()，或者可能会到达最后一个迭代器的末尾。
我不知道是否已经存在此类实现。
更新:
我已经为Andrew Duffy的回答投票 - 没有必要重新发明轮子。 我真的需要更深入地研究Guava。
我为可变数量参数添加了另一个构造函数 - 几乎偏离了主题，因为这里构建类的方式并不是真正感兴趣的，而是它是如何工作的概念。
我有一段时间没有写Java代码了，这让我很好奇自己是否还能做到。
第一次尝试：
import java.util.Iterator;
import java.util.Arrays; /* For sample code */
public class IteratorIterator<T> implements Iterator<T> {
private final Iterator<T> is[];
private int current;
public IteratorIterator(Iterator<T>... iterators)
{
is = iterators;
current = 0;
}
public boolean hasNext() {
while ( current < is.length && !is[current].hasNext() )
current++;
return current < is.length;
}
public T next() {
while ( current < is.length && !is[current].hasNext() )
current++;
return is[current].next();
}
public void remove() { /* not implemented */ }
/* Sample use */
public static void main(String... args)
{
Iterator<Integer> a = Arrays.asList(1,2,3,4).iterator();
Iterator<Integer> b = Arrays.asList(10,11,12).iterator();
Iterator<Integer> c = Arrays.asList(99, 98, 97).iterator();
Iterator<Integer> ii = new IteratorIterator<Integer>(a,b,c);
while ( ii.hasNext() )
System.out.println(ii.next());
}
}
public class IteratorJoin<T> implements Iterator<T> {
private final Iterator<T> first, next;
public IteratorJoin(Iterator<T> first, Iterator<T> next) {
this.first = first;
this.next = next;
}
@Override
public boolean hasNext() {
return first.hasNext() || next.hasNext();
}
@Override
public T next() {
if (first.hasNext())
return first.next();
return next.next();
}
}
Streams.concat(
StreamSupport.stream(<iter1>, false),
StreamSupport.stream(<iter2>, false));
将循环移到一个方法中，并将迭代器传递给该方法。
void methodX(Iterator x) {
while (x.hasNext()) {
....
}
}
迭代器来源于集合或者数组。
为什么不使用已有的方法
Collection.addAll(Collection c);
然后从最后一个对象创建迭代器。
这样，你的迭代器将遍历两个集合的所有内容。
import java.util.Deque;
import java.util.Iterator;
import java.util.concurrent.ConcurrentLinkedDeque;
public class ExtendableIterator<T> implements Iterator<T> {
public Deque<Iterator<T>> its = new ConcurrentLinkedDeque<Iterator<T>>();
public ExtendableIterator() {
}
public ExtendableIterator(Iterator<T> it) {
this();
this.extend(it);
}
@Override
public boolean hasNext() {
// this is true since we never hold empty iterators
return !its.isEmpty() && its.peekLast().hasNext();
}
@Override
public T next() {
T next = its.peekFirst().next();
if (!its.peekFirst().hasNext()) {
its.removeFirst();
}
return next;
}
public void extend(Iterator<T> it) {
if (it.hasNext()) {
its.addLast(it);
}
}
}
import static java.util.Arrays.asList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
public class ConcatIterator<T> implements Iterator<T> {
private final List<Iterable<T>> iterables;
private Iterator<T> current;
@SafeVarargs
public ConcatIterator(final Iterable<T>... iterables) {
this.iterables = new LinkedList<>(asList(iterables));
}
@Override
public boolean hasNext() {
checkNext();
return current != null && current.hasNext();
}
@Override
public T next() {
checkNext();
if (current == null || !current.hasNext()) throw new NoSuchElementException();
return current.next();
}
@Override
public void remove() {
if (current == null) throw new IllegalStateException();
current.remove();
}
private void checkNext() {
while ((current == null || !current.hasNext()) && !iterables.isEmpty()) {
current = iterables.remove(0).iterator();
}
}
}
使用concat方法创建一个Iterable：
@SafeVarargs
public static <T> Iterable<T> concat(final Iterable<T>... iterables) {
return () -> new ConcatIterator<>(iterables);
}
简单的JUnit测试：
@Test
public void testConcat() throws Exception {
final Iterable<Integer> it1 = asList(1, 2, 3);
final Iterable<Integer> it2 = asList(4, 5);
int j = 1;
for (final int i : concat(it1, it2)) {
assertEquals(j, i);
j++;
}
}
LinkedList 仅用于创建一个防御性副本，以便迭代元素。这是一种设计选择。你可以直接使用 asList(..) 并避免复制操作，但在使用 Iterator 之前必须确保不修改原始可迭代对象。选择权在你手中... - benezLinkedList 的复制构造函数。如果你想直接使用 asList(..)，你需要有一个索引变量或者改变代码，因为删除操作将不再起作用。 - benez
concat()方法，而不需要滚动页面（使用#锚点）。然而，该部分没有正确进行URL编码。我已经修复了它（感谢 Firefox 自动对从地址栏复制粘贴的链接进行 URL 编码）。 - BalusC