001 /*
002 * Copyright (C) 2007 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package com.google.common.collect;
018
019 import static com.google.common.base.Preconditions.checkArgument;
020 import static com.google.common.base.Preconditions.checkNotNull;
021 import static com.google.common.base.Preconditions.checkState;
022
023 import com.google.common.annotations.Beta;
024 import com.google.common.annotations.GwtCompatible;
025 import com.google.common.annotations.GwtIncompatible;
026 import com.google.common.base.Function;
027 import com.google.common.base.Joiner;
028 import com.google.common.base.Objects;
029 import com.google.common.base.Optional;
030 import com.google.common.base.Preconditions;
031 import com.google.common.base.Predicate;
032 import com.google.common.base.Predicates;
033
034 import java.util.Arrays;
035 import java.util.Collection;
036 import java.util.Collections;
037 import java.util.Comparator;
038 import java.util.Enumeration;
039 import java.util.Iterator;
040 import java.util.List;
041 import java.util.ListIterator;
042 import java.util.NoSuchElementException;
043 import java.util.PriorityQueue;
044 import java.util.Queue;
045
046 import javax.annotation.Nullable;
047
048 /**
049 * This class contains static utility methods that operate on or return objects
050 * of type {@link Iterator}. Except as noted, each method has a corresponding
051 * {@link Iterable}-based method in the {@link Iterables} class.
052 *
053 * <p><i>Performance notes:</i> Unless otherwise noted, all of the iterators
054 * produced in this class are <i>lazy</i>, which means that they only advance
055 * the backing iteration when absolutely necessary.
056 *
057 * <p>See the Guava User Guide section on <a href=
058 * "http://code.google.com/p/guava-libraries/wiki/CollectionUtilitiesExplained#Iterables">
059 * {@code Iterators}</a>.
060 *
061 * @author Kevin Bourrillion
062 * @author Jared Levy
063 * @since 2.0 (imported from Google Collections Library)
064 */
065 @GwtCompatible(emulated = true)
066 public final class Iterators {
067 private Iterators() {}
068
069 static final UnmodifiableListIterator<Object> EMPTY_LIST_ITERATOR
070 = new UnmodifiableListIterator<Object>() {
071 @Override
072 public boolean hasNext() {
073 return false;
074 }
075 @Override
076 public Object next() {
077 throw new NoSuchElementException();
078 }
079 @Override
080 public boolean hasPrevious() {
081 return false;
082 }
083 @Override
084 public Object previous() {
085 throw new NoSuchElementException();
086 }
087 @Override
088 public int nextIndex() {
089 return 0;
090 }
091 @Override
092 public int previousIndex() {
093 return -1;
094 }
095 };
096
097 /**
098 * Returns the empty iterator.
099 *
100 * <p>The {@link Iterable} equivalent of this method is {@link
101 * ImmutableSet#of()}.
102 */
103 public static <T> UnmodifiableIterator<T> emptyIterator() {
104 return emptyListIterator();
105 }
106
107 /**
108 * Returns the empty iterator.
109 *
110 * <p>The {@link Iterable} equivalent of this method is {@link
111 * ImmutableSet#of()}.
112 */
113 // Casting to any type is safe since there are no actual elements.
114 @SuppressWarnings("unchecked")
115 static <T> UnmodifiableListIterator<T> emptyListIterator() {
116 return (UnmodifiableListIterator<T>) EMPTY_LIST_ITERATOR;
117 }
118
119 private static final Iterator<Object> EMPTY_MODIFIABLE_ITERATOR =
120 new Iterator<Object>() {
121 @Override public boolean hasNext() {
122 return false;
123 }
124
125 @Override public Object next() {
126 throw new NoSuchElementException();
127 }
128
129 @Override public void remove() {
130 throw new IllegalStateException();
131 }
132 };
133
134 /**
135 * Returns the empty {@code Iterator} that throws
136 * {@link IllegalStateException} instead of
137 * {@link UnsupportedOperationException} on a call to
138 * {@link Iterator#remove()}.
139 */
140 // Casting to any type is safe since there are no actual elements.
141 @SuppressWarnings("unchecked")
142 static <T> Iterator<T> emptyModifiableIterator() {
143 return (Iterator<T>) EMPTY_MODIFIABLE_ITERATOR;
144 }
145
146 /** Returns an unmodifiable view of {@code iterator}. */
147 public static <T> UnmodifiableIterator<T> unmodifiableIterator(
148 final Iterator<T> iterator) {
149 checkNotNull(iterator);
150 if (iterator instanceof UnmodifiableIterator) {
151 return (UnmodifiableIterator<T>) iterator;
152 }
153 return new UnmodifiableIterator<T>() {
154 @Override
155 public boolean hasNext() {
156 return iterator.hasNext();
157 }
158 @Override
159 public T next() {
160 return iterator.next();
161 }
162 };
163 }
164
165 /**
166 * Simply returns its argument.
167 *
168 * @deprecated no need to use this
169 * @since 10.0
170 */
171 @Deprecated public static <T> UnmodifiableIterator<T> unmodifiableIterator(
172 UnmodifiableIterator<T> iterator) {
173 return checkNotNull(iterator);
174 }
175
176 /** Returns an unmodifiable view of {@code iterator}. */
177 static <T> UnmodifiableListIterator<T> unmodifiableListIterator(
178 final ListIterator<T> iterator) {
179 checkNotNull(iterator);
180 if (iterator instanceof UnmodifiableListIterator) {
181 return (UnmodifiableListIterator<T>) iterator;
182 }
183 return new UnmodifiableListIterator<T>() {
184 @Override
185 public boolean hasNext() {
186 return iterator.hasNext();
187 }
188 @Override
189 public boolean hasPrevious() {
190 return iterator.hasPrevious();
191 }
192 @Override
193 public T next() {
194 return iterator.next();
195 }
196 @Override
197 public T previous() {
198 return iterator.previous();
199 }
200 @Override
201 public int nextIndex() {
202 return iterator.nextIndex();
203 }
204 @Override
205 public int previousIndex() {
206 return iterator.previousIndex();
207 }
208 };
209 }
210
211 /**
212 * Returns the number of elements remaining in {@code iterator}. The iterator
213 * will be left exhausted: its {@code hasNext()} method will return
214 * {@code false}.
215 */
216 public static int size(Iterator<?> iterator) {
217 int count = 0;
218 while (iterator.hasNext()) {
219 iterator.next();
220 count++;
221 }
222 return count;
223 }
224
225 /**
226 * Returns {@code true} if {@code iterator} contains {@code element}.
227 */
228 public static boolean contains(Iterator<?> iterator, @Nullable Object element)
229 {
230 if (element == null) {
231 while (iterator.hasNext()) {
232 if (iterator.next() == null) {
233 return true;
234 }
235 }
236 } else {
237 while (iterator.hasNext()) {
238 if (element.equals(iterator.next())) {
239 return true;
240 }
241 }
242 }
243 return false;
244 }
245
246 /**
247 * Traverses an iterator and removes every element that belongs to the
248 * provided collection. The iterator will be left exhausted: its
249 * {@code hasNext()} method will return {@code false}.
250 *
251 * @param removeFrom the iterator to (potentially) remove elements from
252 * @param elementsToRemove the elements to remove
253 * @return {@code true} if any element was removed from {@code iterator}
254 */
255 public static boolean removeAll(
256 Iterator<?> removeFrom, Collection<?> elementsToRemove) {
257 checkNotNull(elementsToRemove);
258 boolean modified = false;
259 while (removeFrom.hasNext()) {
260 if (elementsToRemove.contains(removeFrom.next())) {
261 removeFrom.remove();
262 modified = true;
263 }
264 }
265 return modified;
266 }
267
268 /**
269 * Removes every element that satisfies the provided predicate from the
270 * iterator. The iterator will be left exhausted: its {@code hasNext()}
271 * method will return {@code false}.
272 *
273 * @param removeFrom the iterator to (potentially) remove elements from
274 * @param predicate a predicate that determines whether an element should
275 * be removed
276 * @return {@code true} if any elements were removed from the iterator
277 * @since 2.0
278 */
279 public static <T> boolean removeIf(
280 Iterator<T> removeFrom, Predicate<? super T> predicate) {
281 checkNotNull(predicate);
282 boolean modified = false;
283 while (removeFrom.hasNext()) {
284 if (predicate.apply(removeFrom.next())) {
285 removeFrom.remove();
286 modified = true;
287 }
288 }
289 return modified;
290 }
291
292 /**
293 * Traverses an iterator and removes every element that does not belong to the
294 * provided collection. The iterator will be left exhausted: its
295 * {@code hasNext()} method will return {@code false}.
296 *
297 * @param removeFrom the iterator to (potentially) remove elements from
298 * @param elementsToRetain the elements to retain
299 * @return {@code true} if any element was removed from {@code iterator}
300 */
301 public static boolean retainAll(
302 Iterator<?> removeFrom, Collection<?> elementsToRetain) {
303 checkNotNull(elementsToRetain);
304 boolean modified = false;
305 while (removeFrom.hasNext()) {
306 if (!elementsToRetain.contains(removeFrom.next())) {
307 removeFrom.remove();
308 modified = true;
309 }
310 }
311 return modified;
312 }
313
314 /**
315 * Determines whether two iterators contain equal elements in the same order.
316 * More specifically, this method returns {@code true} if {@code iterator1}
317 * and {@code iterator2} contain the same number of elements and every element
318 * of {@code iterator1} is equal to the corresponding element of
319 * {@code iterator2}.
320 *
321 * <p>Note that this will modify the supplied iterators, since they will have
322 * been advanced some number of elements forward.
323 */
324 public static boolean elementsEqual(
325 Iterator<?> iterator1, Iterator<?> iterator2) {
326 while (iterator1.hasNext()) {
327 if (!iterator2.hasNext()) {
328 return false;
329 }
330 Object o1 = iterator1.next();
331 Object o2 = iterator2.next();
332 if (!Objects.equal(o1, o2)) {
333 return false;
334 }
335 }
336 return !iterator2.hasNext();
337 }
338
339 /**
340 * Returns a string representation of {@code iterator}, with the format
341 * {@code [e1, e2, ..., en]}. The iterator will be left exhausted: its
342 * {@code hasNext()} method will return {@code false}.
343 */
344 public static String toString(Iterator<?> iterator) {
345 return Joiner.on(", ")
346 .useForNull("null")
347 .appendTo(new StringBuilder().append('['), iterator)
348 .append(']')
349 .toString();
350 }
351
352 /**
353 * Returns the single element contained in {@code iterator}.
354 *
355 * @throws NoSuchElementException if the iterator is empty
356 * @throws IllegalArgumentException if the iterator contains multiple
357 * elements. The state of the iterator is unspecified.
358 */
359 public static <T> T getOnlyElement(Iterator<T> iterator) {
360 T first = iterator.next();
361 if (!iterator.hasNext()) {
362 return first;
363 }
364
365 StringBuilder sb = new StringBuilder();
366 sb.append("expected one element but was: <" + first);
367 for (int i = 0; i < 4 && iterator.hasNext(); i++) {
368 sb.append(", " + iterator.next());
369 }
370 if (iterator.hasNext()) {
371 sb.append(", ...");
372 }
373 sb.append('>');
374
375 throw new IllegalArgumentException(sb.toString());
376 }
377
378 /**
379 * Returns the single element contained in {@code iterator}, or {@code
380 * defaultValue} if the iterator is empty.
381 *
382 * @throws IllegalArgumentException if the iterator contains multiple
383 * elements. The state of the iterator is unspecified.
384 */
385 public static <T> T getOnlyElement(Iterator<? extends T> iterator, @Nullable T defaultValue) {
386 return iterator.hasNext() ? getOnlyElement(iterator) : defaultValue;
387 }
388
389 /**
390 * Copies an iterator's elements into an array. The iterator will be left
391 * exhausted: its {@code hasNext()} method will return {@code false}.
392 *
393 * @param iterator the iterator to copy
394 * @param type the type of the elements
395 * @return a newly-allocated array into which all the elements of the iterator
396 * have been copied
397 */
398 @GwtIncompatible("Array.newInstance(Class, int)")
399 public static <T> T[] toArray(
400 Iterator<? extends T> iterator, Class<T> type) {
401 List<T> list = Lists.newArrayList(iterator);
402 return Iterables.toArray(list, type);
403 }
404
405 /**
406 * Adds all elements in {@code iterator} to {@code collection}. The iterator
407 * will be left exhausted: its {@code hasNext()} method will return
408 * {@code false}.
409 *
410 * @return {@code true} if {@code collection} was modified as a result of this
411 * operation
412 */
413 public static <T> boolean addAll(
414 Collection<T> addTo, Iterator<? extends T> iterator) {
415 checkNotNull(addTo);
416 boolean wasModified = false;
417 while (iterator.hasNext()) {
418 wasModified |= addTo.add(iterator.next());
419 }
420 return wasModified;
421 }
422
423 /**
424 * Returns the number of elements in the specified iterator that equal the
425 * specified object. The iterator will be left exhausted: its
426 * {@code hasNext()} method will return {@code false}.
427 *
428 * @see Collections#frequency
429 */
430 public static int frequency(Iterator<?> iterator, @Nullable Object element) {
431 int result = 0;
432 if (element == null) {
433 while (iterator.hasNext()) {
434 if (iterator.next() == null) {
435 result++;
436 }
437 }
438 } else {
439 while (iterator.hasNext()) {
440 if (element.equals(iterator.next())) {
441 result++;
442 }
443 }
444 }
445 return result;
446 }
447
448 /**
449 * Returns an iterator that cycles indefinitely over the elements of {@code
450 * iterable}.
451 *
452 * <p>The returned iterator supports {@code remove()} if the provided iterator
453 * does. After {@code remove()} is called, subsequent cycles omit the removed
454 * element, which is no longer in {@code iterable}. The iterator's
455 * {@code hasNext()} method returns {@code true} until {@code iterable} is
456 * empty.
457 *
458 * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an
459 * infinite loop. You should use an explicit {@code break} or be certain that
460 * you will eventually remove all the elements.
461 */
462 public static <T> Iterator<T> cycle(final Iterable<T> iterable) {
463 checkNotNull(iterable);
464 return new Iterator<T>() {
465 Iterator<T> iterator = emptyIterator();
466 Iterator<T> removeFrom;
467
468 @Override
469 public boolean hasNext() {
470 if (!iterator.hasNext()) {
471 iterator = iterable.iterator();
472 }
473 return iterator.hasNext();
474 }
475 @Override
476 public T next() {
477 if (!hasNext()) {
478 throw new NoSuchElementException();
479 }
480 removeFrom = iterator;
481 return iterator.next();
482 }
483 @Override
484 public void remove() {
485 checkState(removeFrom != null,
486 "no calls to next() since last call to remove()");
487 removeFrom.remove();
488 removeFrom = null;
489 }
490 };
491 }
492
493 /**
494 * Returns an iterator that cycles indefinitely over the provided elements.
495 *
496 * <p>The returned iterator supports {@code remove()} if the provided iterator
497 * does. After {@code remove()} is called, subsequent cycles omit the removed
498 * element, but {@code elements} does not change. The iterator's
499 * {@code hasNext()} method returns {@code true} until all of the original
500 * elements have been removed.
501 *
502 * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an
503 * infinite loop. You should use an explicit {@code break} or be certain that
504 * you will eventually remove all the elements.
505 */
506 public static <T> Iterator<T> cycle(T... elements) {
507 return cycle(Lists.newArrayList(elements));
508 }
509
510 /**
511 * Combines two iterators into a single iterator. The returned iterator
512 * iterates across the elements in {@code a}, followed by the elements in
513 * {@code b}. The source iterators are not polled until necessary.
514 *
515 * <p>The returned iterator supports {@code remove()} when the corresponding
516 * input iterator supports it.
517 *
518 * <p><b>Note:</b> the current implementation is not suitable for nested
519 * concatenated iterators, i.e. the following should be avoided when in a loop:
520 * {@code iterator = Iterators.concat(iterator, suffix);}, since iteration over the
521 * resulting iterator has a cubic complexity to the depth of the nesting.
522 */
523 @SuppressWarnings("unchecked")
524 public static <T> Iterator<T> concat(Iterator<? extends T> a,
525 Iterator<? extends T> b) {
526 checkNotNull(a);
527 checkNotNull(b);
528 return concat(Arrays.asList(a, b).iterator());
529 }
530
531 /**
532 * Combines three iterators into a single iterator. The returned iterator
533 * iterates across the elements in {@code a}, followed by the elements in
534 * {@code b}, followed by the elements in {@code c}. The source iterators
535 * are not polled until necessary.
536 *
537 * <p>The returned iterator supports {@code remove()} when the corresponding
538 * input iterator supports it.
539 *
540 * <p><b>Note:</b> the current implementation is not suitable for nested
541 * concatenated iterators, i.e. the following should be avoided when in a loop:
542 * {@code iterator = Iterators.concat(iterator, suffix);}, since iteration over the
543 * resulting iterator has a cubic complexity to the depth of the nesting.
544 */
545 @SuppressWarnings("unchecked")
546 public static <T> Iterator<T> concat(Iterator<? extends T> a,
547 Iterator<? extends T> b, Iterator<? extends T> c) {
548 checkNotNull(a);
549 checkNotNull(b);
550 checkNotNull(c);
551 return concat(Arrays.asList(a, b, c).iterator());
552 }
553
554 /**
555 * Combines four iterators into a single iterator. The returned iterator
556 * iterates across the elements in {@code a}, followed by the elements in
557 * {@code b}, followed by the elements in {@code c}, followed by the elements
558 * in {@code d}. The source iterators are not polled until necessary.
559 *
560 * <p>The returned iterator supports {@code remove()} when the corresponding
561 * input iterator supports it.
562 *
563 * <p><b>Note:</b> the current implementation is not suitable for nested
564 * concatenated iterators, i.e. the following should be avoided when in a loop:
565 * {@code iterator = Iterators.concat(iterator, suffix);}, since iteration over the
566 * resulting iterator has a cubic complexity to the depth of the nesting.
567 */
568 @SuppressWarnings("unchecked")
569 public static <T> Iterator<T> concat(Iterator<? extends T> a,
570 Iterator<? extends T> b, Iterator<? extends T> c,
571 Iterator<? extends T> d) {
572 checkNotNull(a);
573 checkNotNull(b);
574 checkNotNull(c);
575 checkNotNull(d);
576 return concat(Arrays.asList(a, b, c, d).iterator());
577 }
578
579 /**
580 * Combines multiple iterators into a single iterator. The returned iterator
581 * iterates across the elements of each iterator in {@code inputs}. The input
582 * iterators are not polled until necessary.
583 *
584 * <p>The returned iterator supports {@code remove()} when the corresponding
585 * input iterator supports it.
586 *
587 * <p><b>Note:</b> the current implementation is not suitable for nested
588 * concatenated iterators, i.e. the following should be avoided when in a loop:
589 * {@code iterator = Iterators.concat(iterator, suffix);}, since iteration over the
590 * resulting iterator has a cubic complexity to the depth of the nesting.
591 *
592 * @throws NullPointerException if any of the provided iterators is null
593 */
594 public static <T> Iterator<T> concat(Iterator<? extends T>... inputs) {
595 return concat(ImmutableList.copyOf(inputs).iterator());
596 }
597
598 /**
599 * Combines multiple iterators into a single iterator. The returned iterator
600 * iterates across the elements of each iterator in {@code inputs}. The input
601 * iterators are not polled until necessary.
602 *
603 * <p>The returned iterator supports {@code remove()} when the corresponding
604 * input iterator supports it. The methods of the returned iterator may throw
605 * {@code NullPointerException} if any of the input iterators is null.
606 *
607 * <p><b>Note:</b> the current implementation is not suitable for nested
608 * concatenated iterators, i.e. the following should be avoided when in a loop:
609 * {@code iterator = Iterators.concat(iterator, suffix);}, since iteration over the
610 * resulting iterator has a cubic complexity to the depth of the nesting.
611 */
612 public static <T> Iterator<T> concat(
613 final Iterator<? extends Iterator<? extends T>> inputs) {
614 checkNotNull(inputs);
615 return new Iterator<T>() {
616 Iterator<? extends T> current = emptyIterator();
617 Iterator<? extends T> removeFrom;
618
619 @Override
620 public boolean hasNext() {
621 // http://code.google.com/p/google-collections/issues/detail?id=151
622 // current.hasNext() might be relatively expensive, worth minimizing.
623 boolean currentHasNext;
624 // checkNotNull eager for GWT
625 // note: it must be here & not where 'current' is assigned,
626 // because otherwise we'll have called inputs.next() before throwing
627 // the first NPE, and the next time around we'll call inputs.next()
628 // again, incorrectly moving beyond the error.
629 while (!(currentHasNext = checkNotNull(current).hasNext())
630 && inputs.hasNext()) {
631 current = inputs.next();
632 }
633 return currentHasNext;
634 }
635 @Override
636 public T next() {
637 if (!hasNext()) {
638 throw new NoSuchElementException();
639 }
640 removeFrom = current;
641 return current.next();
642 }
643 @Override
644 public void remove() {
645 checkState(removeFrom != null,
646 "no calls to next() since last call to remove()");
647 removeFrom.remove();
648 removeFrom = null;
649 }
650 };
651 }
652
653 /**
654 * Divides an iterator into unmodifiable sublists of the given size (the final
655 * list may be smaller). For example, partitioning an iterator containing
656 * {@code [a, b, c, d, e]} with a partition size of 3 yields {@code
657 * [[a, b, c], [d, e]]} -- an outer iterator containing two inner lists of
658 * three and two elements, all in the original order.
659 *
660 * <p>The returned lists implement {@link java.util.RandomAccess}.
661 *
662 * @param iterator the iterator to return a partitioned view of
663 * @param size the desired size of each partition (the last may be smaller)
664 * @return an iterator of immutable lists containing the elements of {@code
665 * iterator} divided into partitions
666 * @throws IllegalArgumentException if {@code size} is nonpositive
667 */
668 public static <T> UnmodifiableIterator<List<T>> partition(
669 Iterator<T> iterator, int size) {
670 return partitionImpl(iterator, size, false);
671 }
672
673 /**
674 * Divides an iterator into unmodifiable sublists of the given size, padding
675 * the final iterator with null values if necessary. For example, partitioning
676 * an iterator containing {@code [a, b, c, d, e]} with a partition size of 3
677 * yields {@code [[a, b, c], [d, e, null]]} -- an outer iterator containing
678 * two inner lists of three elements each, all in the original order.
679 *
680 * <p>The returned lists implement {@link java.util.RandomAccess}.
681 *
682 * @param iterator the iterator to return a partitioned view of
683 * @param size the desired size of each partition
684 * @return an iterator of immutable lists containing the elements of {@code
685 * iterator} divided into partitions (the final iterable may have
686 * trailing null elements)
687 * @throws IllegalArgumentException if {@code size} is nonpositive
688 */
689 public static <T> UnmodifiableIterator<List<T>> paddedPartition(
690 Iterator<T> iterator, int size) {
691 return partitionImpl(iterator, size, true);
692 }
693
694 private static <T> UnmodifiableIterator<List<T>> partitionImpl(
695 final Iterator<T> iterator, final int size, final boolean pad) {
696 checkNotNull(iterator);
697 checkArgument(size > 0);
698 return new UnmodifiableIterator<List<T>>() {
699 @Override
700 public boolean hasNext() {
701 return iterator.hasNext();
702 }
703 @Override
704 public List<T> next() {
705 if (!hasNext()) {
706 throw new NoSuchElementException();
707 }
708 Object[] array = new Object[size];
709 int count = 0;
710 for (; count < size && iterator.hasNext(); count++) {
711 array[count] = iterator.next();
712 }
713 for (int i = count; i < size; i++) {
714 array[i] = null; // for GWT
715 }
716
717 @SuppressWarnings("unchecked") // we only put Ts in it
718 List<T> list = Collections.unmodifiableList(
719 (List<T>) Arrays.asList(array));
720 return (pad || count == size) ? list : list.subList(0, count);
721 }
722 };
723 }
724
725 /**
726 * Returns the elements of {@code unfiltered} that satisfy a predicate.
727 */
728 public static <T> UnmodifiableIterator<T> filter(
729 final Iterator<T> unfiltered, final Predicate<? super T> predicate) {
730 checkNotNull(unfiltered);
731 checkNotNull(predicate);
732 return new AbstractIterator<T>() {
733 @Override protected T computeNext() {
734 while (unfiltered.hasNext()) {
735 T element = unfiltered.next();
736 if (predicate.apply(element)) {
737 return element;
738 }
739 }
740 return endOfData();
741 }
742 };
743 }
744
745 /**
746 * Returns all instances of class {@code type} in {@code unfiltered}. The
747 * returned iterator has elements whose class is {@code type} or a subclass of
748 * {@code type}.
749 *
750 * @param unfiltered an iterator containing objects of any type
751 * @param type the type of elements desired
752 * @return an unmodifiable iterator containing all elements of the original
753 * iterator that were of the requested type
754 */
755 @SuppressWarnings("unchecked") // can cast to <T> because non-Ts are removed
756 @GwtIncompatible("Class.isInstance")
757 public static <T> UnmodifiableIterator<T> filter(
758 Iterator<?> unfiltered, Class<T> type) {
759 return (UnmodifiableIterator<T>)
760 filter(unfiltered, Predicates.instanceOf(type));
761 }
762
763 /**
764 * Returns {@code true} if one or more elements returned by {@code iterator}
765 * satisfy the given predicate.
766 */
767 public static <T> boolean any(
768 Iterator<T> iterator, Predicate<? super T> predicate) {
769 checkNotNull(predicate);
770 while (iterator.hasNext()) {
771 T element = iterator.next();
772 if (predicate.apply(element)) {
773 return true;
774 }
775 }
776 return false;
777 }
778
779 /**
780 * Returns {@code true} if every element returned by {@code iterator}
781 * satisfies the given predicate. If {@code iterator} is empty, {@code true}
782 * is returned.
783 */
784 public static <T> boolean all(
785 Iterator<T> iterator, Predicate<? super T> predicate) {
786 checkNotNull(predicate);
787 while (iterator.hasNext()) {
788 T element = iterator.next();
789 if (!predicate.apply(element)) {
790 return false;
791 }
792 }
793 return true;
794 }
795
796 /**
797 * Returns the first element in {@code iterator} that satisfies the given
798 * predicate; use this method only when such an element is known to exist. If
799 * no such element is found, the iterator will be left exhausted: its {@code
800 * hasNext()} method will return {@code false}. If it is possible that
801 * <i>no</i> element will match, use {@link #tryFind} or {@link
802 * #find(Iterator, Predicate, Object)} instead.
803 *
804 * @throws NoSuchElementException if no element in {@code iterator} matches
805 * the given predicate
806 */
807 public static <T> T find(
808 Iterator<T> iterator, Predicate<? super T> predicate) {
809 return filter(iterator, predicate).next();
810 }
811
812 /**
813 * Returns the first element in {@code iterator} that satisfies the given
814 * predicate. If no such element is found, {@code defaultValue} will be
815 * returned from this method and the iterator will be left exhausted: its
816 * {@code hasNext()} method will return {@code false}. Note that this can
817 * usually be handled more naturally using {@code
818 * tryFind(iterator, predicate).or(defaultValue)}.
819 *
820 * @since 7.0
821 */
822 public static <T> T find(Iterator<? extends T> iterator, Predicate<? super T> predicate,
823 @Nullable T defaultValue) {
824 UnmodifiableIterator<? extends T> filteredIterator = filter(iterator, predicate);
825 return filteredIterator.hasNext() ? filteredIterator.next() : defaultValue;
826 }
827
828 /**
829 * Returns an {@link Optional} containing the first element in {@code
830 * iterator} that satisfies the given predicate, if such an element exists. If
831 * no such element is found, an empty {@link Optional} will be returned from
832 * this method and the the iterator will be left exhausted: its {@code
833 * hasNext()} method will return {@code false}.
834 *
835 * <p><b>Warning:</b> avoid using a {@code predicate} that matches {@code
836 * null}. If {@code null} is matched in {@code iterator}, a
837 * NullPointerException will be thrown.
838 *
839 * @since 11.0
840 */
841 public static <T> Optional<T> tryFind(
842 Iterator<T> iterator, Predicate<? super T> predicate) {
843 UnmodifiableIterator<T> filteredIterator = filter(iterator, predicate);
844 return filteredIterator.hasNext()
845 ? Optional.of(filteredIterator.next())
846 : Optional.<T>absent();
847 }
848
849 /**
850 * Returns the index in {@code iterator} of the first element that satisfies
851 * the provided {@code predicate}, or {@code -1} if the Iterator has no such
852 * elements.
853 *
854 * <p>More formally, returns the lowest index {@code i} such that
855 * {@code predicate.apply(Iterators.get(iterator, i))} returns {@code true},
856 * or {@code -1} if there is no such index.
857 *
858 * <p>If -1 is returned, the iterator will be left exhausted: its
859 * {@code hasNext()} method will return {@code false}. Otherwise,
860 * the iterator will be set to the element which satisfies the
861 * {@code predicate}.
862 *
863 * @since 2.0
864 */
865 public static <T> int indexOf(
866 Iterator<T> iterator, Predicate<? super T> predicate) {
867 checkNotNull(predicate, "predicate");
868 int i = 0;
869 while (iterator.hasNext()) {
870 T current = iterator.next();
871 if (predicate.apply(current)) {
872 return i;
873 }
874 i++;
875 }
876 return -1;
877 }
878
879 /**
880 * Returns an iterator that applies {@code function} to each element of {@code
881 * fromIterator}.
882 *
883 * <p>The returned iterator supports {@code remove()} if the provided iterator
884 * does. After a successful {@code remove()} call, {@code fromIterator} no
885 * longer contains the corresponding element.
886 */
887 public static <F, T> Iterator<T> transform(final Iterator<F> fromIterator,
888 final Function<? super F, ? extends T> function) {
889 checkNotNull(function);
890 return new TransformedIterator<F, T>(fromIterator) {
891 @Override
892 T transform(F from) {
893 return function.apply(from);
894 }
895 };
896 }
897
898 /**
899 * Advances {@code iterator} {@code position + 1} times, returning the
900 * element at the {@code position}th position.
901 *
902 * @param position position of the element to return
903 * @return the element at the specified position in {@code iterator}
904 * @throws IndexOutOfBoundsException if {@code position} is negative or
905 * greater than or equal to the number of elements remaining in
906 * {@code iterator}
907 */
908 public static <T> T get(Iterator<T> iterator, int position) {
909 checkNonnegative(position);
910
911 int skipped = 0;
912 while (iterator.hasNext()) {
913 T t = iterator.next();
914 if (skipped++ == position) {
915 return t;
916 }
917 }
918
919 throw new IndexOutOfBoundsException("position (" + position
920 + ") must be less than the number of elements that remained ("
921 + skipped + ")");
922 }
923
924 private static void checkNonnegative(int position) {
925 if (position < 0) {
926 throw new IndexOutOfBoundsException("position (" + position
927 + ") must not be negative");
928 }
929 }
930
931 /**
932 * Advances {@code iterator} {@code position + 1} times, returning the
933 * element at the {@code position}th position or {@code defaultValue}
934 * otherwise.
935 *
936 * @param position position of the element to return
937 * @param defaultValue the default value to return if the iterator is empty
938 * or if {@code position} is greater than the number of elements
939 * remaining in {@code iterator}
940 * @return the element at the specified position in {@code iterator} or
941 * {@code defaultValue} if {@code iterator} produces fewer than
942 * {@code position + 1} elements.
943 * @throws IndexOutOfBoundsException if {@code position} is negative
944 * @since 4.0
945 */
946 public static <T> T get(Iterator<? extends T> iterator, int position, @Nullable T defaultValue) {
947 checkNonnegative(position);
948
949 try {
950 return get(iterator, position);
951 } catch (IndexOutOfBoundsException e) {
952 return defaultValue;
953 }
954 }
955
956 /**
957 * Returns the next element in {@code iterator} or {@code defaultValue} if
958 * the iterator is empty. The {@link Iterables} analog to this method is
959 * {@link Iterables#getFirst}.
960 *
961 * @param defaultValue the default value to return if the iterator is empty
962 * @return the next element of {@code iterator} or the default value
963 * @since 7.0
964 */
965 public static <T> T getNext(Iterator<? extends T> iterator, @Nullable T defaultValue) {
966 return iterator.hasNext() ? iterator.next() : defaultValue;
967 }
968
969 /**
970 * Advances {@code iterator} to the end, returning the last element.
971 *
972 * @return the last element of {@code iterator}
973 * @throws NoSuchElementException if the iterator is empty
974 */
975 public static <T> T getLast(Iterator<T> iterator) {
976 while (true) {
977 T current = iterator.next();
978 if (!iterator.hasNext()) {
979 return current;
980 }
981 }
982 }
983
984 /**
985 * Advances {@code iterator} to the end, returning the last element or
986 * {@code defaultValue} if the iterator is empty.
987 *
988 * @param defaultValue the default value to return if the iterator is empty
989 * @return the last element of {@code iterator}
990 * @since 3.0
991 */
992 public static <T> T getLast(Iterator<? extends T> iterator, @Nullable T defaultValue) {
993 return iterator.hasNext() ? getLast(iterator) : defaultValue;
994 }
995
996 /**
997 * Calls {@code next()} on {@code iterator}, either {@code numberToSkip} times
998 * or until {@code hasNext()} returns {@code false}, whichever comes first.
999 *
1000 * @return the number of elements skipped
1001 * @since 3.0
1002 * @deprecated This method has been renamed to {@link #advance(java.util.Iterator, int) advance}.
1003 * This method is scheduled to be deleted in Guava 14.0.
1004 */
1005 @Beta
1006 @Deprecated
1007 public static int skip(Iterator<?> iterator, int numberToSkip) {
1008 return advance(iterator, numberToSkip);
1009 }
1010
1011 /**
1012 * Calls {@code next()} on {@code iterator}, either {@code numberToAdvance} times
1013 * or until {@code hasNext()} returns {@code false}, whichever comes first.
1014 *
1015 * @return the number of elements the iterator was advanced
1016 * @since 13.0 (since 3.0 as {@code Iterators.skip})
1017 */
1018 public static int advance(Iterator<?> iterator, int numberToAdvance) {
1019 checkNotNull(iterator);
1020 checkArgument(numberToAdvance >= 0, "number to advance cannot be negative");
1021
1022 int i;
1023 for (i = 0; i < numberToAdvance && iterator.hasNext(); i++) {
1024 iterator.next();
1025 }
1026 return i;
1027 }
1028
1029 /**
1030 * Creates an iterator returning the first {@code limitSize} elements of the
1031 * given iterator. If the original iterator does not contain that many
1032 * elements, the returned iterator will have the same behavior as the original
1033 * iterator. The returned iterator supports {@code remove()} if the original
1034 * iterator does.
1035 *
1036 * @param iterator the iterator to limit
1037 * @param limitSize the maximum number of elements in the returned iterator
1038 * @throws IllegalArgumentException if {@code limitSize} is negative
1039 * @since 3.0
1040 */
1041 public static <T> Iterator<T> limit(
1042 final Iterator<T> iterator, final int limitSize) {
1043 checkNotNull(iterator);
1044 checkArgument(limitSize >= 0, "limit is negative");
1045 return new Iterator<T>() {
1046 private int count;
1047
1048 @Override
1049 public boolean hasNext() {
1050 return count < limitSize && iterator.hasNext();
1051 }
1052
1053 @Override
1054 public T next() {
1055 if (!hasNext()) {
1056 throw new NoSuchElementException();
1057 }
1058 count++;
1059 return iterator.next();
1060 }
1061
1062 @Override
1063 public void remove() {
1064 iterator.remove();
1065 }
1066 };
1067 }
1068
1069 /**
1070 * Returns a view of the supplied {@code iterator} that removes each element
1071 * from the supplied {@code iterator} as it is returned.
1072 *
1073 * <p>The provided iterator must support {@link Iterator#remove()} or
1074 * else the returned iterator will fail on the first call to {@code
1075 * next}.
1076 *
1077 * @param iterator the iterator to remove and return elements from
1078 * @return an iterator that removes and returns elements from the
1079 * supplied iterator
1080 * @since 2.0
1081 */
1082 public static <T> Iterator<T> consumingIterator(final Iterator<T> iterator) {
1083 checkNotNull(iterator);
1084 return new UnmodifiableIterator<T>() {
1085 @Override
1086 public boolean hasNext() {
1087 return iterator.hasNext();
1088 }
1089
1090 @Override
1091 public T next() {
1092 T next = iterator.next();
1093 iterator.remove();
1094 return next;
1095 }
1096 };
1097 }
1098
1099 // Methods only in Iterators, not in Iterables
1100
1101 /**
1102 * Clears the iterator using its remove method.
1103 */
1104 static void clear(Iterator<?> iterator) {
1105 checkNotNull(iterator);
1106 while (iterator.hasNext()) {
1107 iterator.next();
1108 iterator.remove();
1109 }
1110 }
1111
1112 /**
1113 * Returns an iterator containing the elements of {@code array} in order. The
1114 * returned iterator is a view of the array; subsequent changes to the array
1115 * will be reflected in the iterator.
1116 *
1117 * <p><b>Note:</b> It is often preferable to represent your data using a
1118 * collection type, for example using {@link Arrays#asList(Object[])}, making
1119 * this method unnecessary.
1120 *
1121 * <p>The {@code Iterable} equivalent of this method is either {@link
1122 * Arrays#asList(Object[])}, {@link ImmutableList#copyOf(Object[])}},
1123 * or {@link ImmutableList#of}.
1124 */
1125 public static <T> UnmodifiableIterator<T> forArray(final T... array) {
1126 // TODO(kevinb): compare performance with Arrays.asList(array).iterator().
1127 checkNotNull(array); // eager for GWT.
1128 return new AbstractIndexedListIterator<T>(array.length) {
1129 @Override protected T get(int index) {
1130 return array[index];
1131 }
1132 };
1133 }
1134
1135 /**
1136 * Returns a list iterator containing the elements in the specified range of
1137 * {@code array} in order, starting at the specified index.
1138 *
1139 * <p>The {@code Iterable} equivalent of this method is {@code
1140 * Arrays.asList(array).subList(offset, offset + length).listIterator(index)}.
1141 */
1142 static <T> UnmodifiableListIterator<T> forArray(
1143 final T[] array, final int offset, int length, int index) {
1144 checkArgument(length >= 0);
1145 int end = offset + length;
1146
1147 // Technically we should give a slightly more descriptive error on overflow
1148 Preconditions.checkPositionIndexes(offset, end, array.length);
1149
1150 /*
1151 * We can't use call the two-arg constructor with arguments (offset, end)
1152 * because the returned Iterator is a ListIterator that may be moved back
1153 * past the beginning of the iteration.
1154 */
1155 return new AbstractIndexedListIterator<T>(length, index) {
1156 @Override protected T get(int index) {
1157 return array[offset + index];
1158 }
1159 };
1160 }
1161
1162 /**
1163 * Returns an iterator containing only {@code value}.
1164 *
1165 * <p>The {@link Iterable} equivalent of this method is {@link
1166 * Collections#singleton}.
1167 */
1168 public static <T> UnmodifiableIterator<T> singletonIterator(
1169 @Nullable final T value) {
1170 return new UnmodifiableIterator<T>() {
1171 boolean done;
1172 @Override
1173 public boolean hasNext() {
1174 return !done;
1175 }
1176 @Override
1177 public T next() {
1178 if (done) {
1179 throw new NoSuchElementException();
1180 }
1181 done = true;
1182 return value;
1183 }
1184 };
1185 }
1186
1187 /**
1188 * Adapts an {@code Enumeration} to the {@code Iterator} interface.
1189 *
1190 * <p>This method has no equivalent in {@link Iterables} because viewing an
1191 * {@code Enumeration} as an {@code Iterable} is impossible. However, the
1192 * contents can be <i>copied</i> into a collection using {@link
1193 * Collections#list}.
1194 */
1195 public static <T> UnmodifiableIterator<T> forEnumeration(
1196 final Enumeration<T> enumeration) {
1197 checkNotNull(enumeration);
1198 return new UnmodifiableIterator<T>() {
1199 @Override
1200 public boolean hasNext() {
1201 return enumeration.hasMoreElements();
1202 }
1203 @Override
1204 public T next() {
1205 return enumeration.nextElement();
1206 }
1207 };
1208 }
1209
1210 /**
1211 * Adapts an {@code Iterator} to the {@code Enumeration} interface.
1212 *
1213 * <p>The {@code Iterable} equivalent of this method is either {@link
1214 * Collections#enumeration} (if you have a {@link Collection}), or
1215 * {@code Iterators.asEnumeration(collection.iterator())}.
1216 */
1217 public static <T> Enumeration<T> asEnumeration(final Iterator<T> iterator) {
1218 checkNotNull(iterator);
1219 return new Enumeration<T>() {
1220 @Override
1221 public boolean hasMoreElements() {
1222 return iterator.hasNext();
1223 }
1224 @Override
1225 public T nextElement() {
1226 return iterator.next();
1227 }
1228 };
1229 }
1230
1231 /**
1232 * Implementation of PeekingIterator that avoids peeking unless necessary.
1233 */
1234 private static class PeekingImpl<E> implements PeekingIterator<E> {
1235
1236 private final Iterator<? extends E> iterator;
1237 private boolean hasPeeked;
1238 private E peekedElement;
1239
1240 public PeekingImpl(Iterator<? extends E> iterator) {
1241 this.iterator = checkNotNull(iterator);
1242 }
1243
1244 @Override
1245 public boolean hasNext() {
1246 return hasPeeked || iterator.hasNext();
1247 }
1248
1249 @Override
1250 public E next() {
1251 if (!hasPeeked) {
1252 return iterator.next();
1253 }
1254 E result = peekedElement;
1255 hasPeeked = false;
1256 peekedElement = null;
1257 return result;
1258 }
1259
1260 @Override
1261 public void remove() {
1262 checkState(!hasPeeked, "Can't remove after you've peeked at next");
1263 iterator.remove();
1264 }
1265
1266 @Override
1267 public E peek() {
1268 if (!hasPeeked) {
1269 peekedElement = iterator.next();
1270 hasPeeked = true;
1271 }
1272 return peekedElement;
1273 }
1274 }
1275
1276 /**
1277 * Returns a {@code PeekingIterator} backed by the given iterator.
1278 *
1279 * <p>Calls to the {@code peek} method with no intervening calls to {@code
1280 * next} do not affect the iteration, and hence return the same object each
1281 * time. A subsequent call to {@code next} is guaranteed to return the same
1282 * object again. For example: <pre> {@code
1283 *
1284 * PeekingIterator<String> peekingIterator =
1285 * Iterators.peekingIterator(Iterators.forArray("a", "b"));
1286 * String a1 = peekingIterator.peek(); // returns "a"
1287 * String a2 = peekingIterator.peek(); // also returns "a"
1288 * String a3 = peekingIterator.next(); // also returns "a"}</pre>
1289 *
1290 * Any structural changes to the underlying iteration (aside from those
1291 * performed by the iterator's own {@link PeekingIterator#remove()} method)
1292 * will leave the iterator in an undefined state.
1293 *
1294 * <p>The returned iterator does not support removal after peeking, as
1295 * explained by {@link PeekingIterator#remove()}.
1296 *
1297 * <p>Note: If the given iterator is already a {@code PeekingIterator},
1298 * it <i>might</i> be returned to the caller, although this is neither
1299 * guaranteed to occur nor required to be consistent. For example, this
1300 * method <i>might</i> choose to pass through recognized implementations of
1301 * {@code PeekingIterator} when the behavior of the implementation is
1302 * known to meet the contract guaranteed by this method.
1303 *
1304 * <p>There is no {@link Iterable} equivalent to this method, so use this
1305 * method to wrap each individual iterator as it is generated.
1306 *
1307 * @param iterator the backing iterator. The {@link PeekingIterator} assumes
1308 * ownership of this iterator, so users should cease making direct calls
1309 * to it after calling this method.
1310 * @return a peeking iterator backed by that iterator. Apart from the
1311 * additional {@link PeekingIterator#peek()} method, this iterator behaves
1312 * exactly the same as {@code iterator}.
1313 */
1314 public static <T> PeekingIterator<T> peekingIterator(
1315 Iterator<? extends T> iterator) {
1316 if (iterator instanceof PeekingImpl) {
1317 // Safe to cast <? extends T> to <T> because PeekingImpl only uses T
1318 // covariantly (and cannot be subclassed to add non-covariant uses).
1319 @SuppressWarnings("unchecked")
1320 PeekingImpl<T> peeking = (PeekingImpl<T>) iterator;
1321 return peeking;
1322 }
1323 return new PeekingImpl<T>(iterator);
1324 }
1325
1326 /**
1327 * Simply returns its argument.
1328 *
1329 * @deprecated no need to use this
1330 * @since 10.0
1331 */
1332 @Deprecated public static <T> PeekingIterator<T> peekingIterator(
1333 PeekingIterator<T> iterator) {
1334 return checkNotNull(iterator);
1335 }
1336
1337 /**
1338 * Returns an iterator over the merged contents of all given
1339 * {@code iterators}, traversing every element of the input iterators.
1340 * Equivalent entries will not be de-duplicated.
1341 *
1342 * <p>Callers must ensure that the source {@code iterators} are in
1343 * non-descending order as this method does not sort its input.
1344 *
1345 * <p>For any equivalent elements across all {@code iterators}, it is
1346 * undefined which element is returned first.
1347 *
1348 * @since 11.0
1349 */
1350 @Beta
1351 public static <T> UnmodifiableIterator<T> mergeSorted(
1352 Iterable<? extends Iterator<? extends T>> iterators,
1353 Comparator<? super T> comparator) {
1354 checkNotNull(iterators, "iterators");
1355 checkNotNull(comparator, "comparator");
1356
1357 return new MergingIterator<T>(iterators, comparator);
1358 }
1359
1360 /**
1361 * An iterator that performs a lazy N-way merge, calculating the next value
1362 * each time the iterator is polled. This amortizes the sorting cost over the
1363 * iteration and requires less memory than sorting all elements at once.
1364 *
1365 * <p>Retrieving a single element takes approximately O(log(M)) time, where M
1366 * is the number of iterators. (Retrieving all elements takes approximately
1367 * O(N*log(M)) time, where N is the total number of elements.)
1368 */
1369 private static class MergingIterator<T> extends AbstractIterator<T> {
1370 final Queue<PeekingIterator<T>> queue;
1371 final Comparator<? super T> comparator;
1372
1373 public MergingIterator(Iterable<? extends Iterator<? extends T>> iterators,
1374 Comparator<? super T> itemComparator) {
1375 this.comparator = itemComparator;
1376
1377 // A comparator that's used by the heap, allowing the heap
1378 // to be sorted based on the top of each iterator.
1379 Comparator<PeekingIterator<T>> heapComparator =
1380 new Comparator<PeekingIterator<T>>() {
1381 @Override
1382 public int compare(PeekingIterator<T> o1, PeekingIterator<T> o2) {
1383 return comparator.compare(o1.peek(), o2.peek());
1384 }
1385 };
1386
1387 queue = new PriorityQueue<PeekingIterator<T>>(2, heapComparator);
1388
1389 for (Iterator<? extends T> iterator : iterators) {
1390 if (iterator.hasNext()) {
1391 queue.add(Iterators.peekingIterator(iterator));
1392 }
1393 }
1394 }
1395
1396 @Override
1397 protected T computeNext() {
1398 if (queue.isEmpty()) {
1399 return endOfData();
1400 }
1401
1402 PeekingIterator<T> nextIter = queue.poll();
1403 T next = nextIter.next();
1404
1405 if (nextIter.hasNext()) {
1406 queue.add(nextIter);
1407 }
1408
1409 return next;
1410 }
1411 }
1412
1413 /**
1414 * Precondition tester for {@code Iterator.remove()} that throws an exception with a consistent
1415 * error message.
1416 */
1417 static void checkRemove(boolean canRemove) {
1418 checkState(canRemove, "no calls to next() since the last call to remove()");
1419 }
1420
1421 /**
1422 * Used to avoid http://bugs.sun.com/view_bug.do?bug_id=6558557
1423 */
1424 static <T> ListIterator<T> cast(Iterator<T> iterator) {
1425 return (ListIterator<T>) iterator;
1426 }
1427 }