android/guava/src/com/google/common/collect/Iterators.java
public static <T> Iterator<T> cycle(final Iterable<T> iterable) {
    checkNotNull(iterable);
    return new Iterator<T>() {
      Iterator<T> iterator = emptyModifiableIterator();

      @Override
      public boolean hasNext() {
        /*
         * Don't store a new Iterator until we know the user can't remove() the last returned
         * element anymore. Otherwise, when we remove from the old iterator, we may be invalidating
         * the new one. The result is a ConcurrentModificationException or other bad behavior.
         *
         * (If we decide that we really, really hate allocating two Iterators per cycle instead of
         * one, we can optimistically store the new Iterator and then be willing to throw it out if
         * the user calls remove().)
         */
        return iterator.hasNext() || iterable.iterator().hasNext();
      }

      @Override
      public T next() {
        if (!iterator.hasNext()) {
          iterator = iterable.iterator();
          if (!iterator.hasNext()) {
            throw new NoSuchElementException();
          }
        }
        return iterator.next();
      }

      @Override
      public void remove() {
        iterator.remove();
      }
    };
  }
public static <T> Iterator<T> cycle(final Iterable<T> iterable) {
    checkNotNull(iterable);
    return new Iterator<T>() {
      Iterator<T> iterator = emptyModifiableIterator();

      @Override
      public boolean hasNext() {
        /*
         * Don't store a new Iterator until we know the user can't remove() the last returned
         * element anymore. Otherwise, when we remove from the old iterator, we may be invalidating
         * the new one. The result is a ConcurrentModificationException or other bad behavior.
         *
         * (If we decide that we really, really hate allocating two Iterators per cycle instead of
         * one, we can optimistically store the new Iterator and then be willing to throw it out if
         * the user calls remove().)
         */
        return iterator.hasNext() || iterable.iterator().hasNext();
      }

      @Override
      public T next() {
        if (!iterator.hasNext()) {
          iterator = iterable.iterator();
          if (!iterator.hasNext()) {
            throw new NoSuchElementException();
          }
        }
        return iterator.next();
      }

      @Override
      public void remove() {
        iterator.remove();
      }
    };
  }
public static < T > Iterator < T > cycle ( final Iterable < T > iterable ) { checkNotNull ( iterable ) ; return new Iterator < T > ( ) { Iterator < T > iterator = emptyModifiableIterator ( ) ; @ Override public boolean hasNext ( ) { /*
         * Don't store a new Iterator until we know the user can't remove() the last returned
         * element anymore. Otherwise, when we remove from the old iterator, we may be invalidating
         * the new one. The result is a ConcurrentModificationException or other bad behavior.
         *
         * (If we decide that we really, really hate allocating two Iterators per cycle instead of
         * one, we can optimistically store the new Iterator and then be willing to throw it out if
         * the user calls remove().)
         */ return iterator . hasNext ( ) || iterable . iterator ( ) . hasNext ( ) ; } @ Override public T next ( ) { if ( ! iterator . hasNext ( ) ) { iterator = iterable . iterator ( ) ; if ( ! iterator . hasNext ( ) ) { throw new NoSuchElementException ( ) ; } } return iterator . next ( ) ; } @ Override public void remove ( ) { iterator . remove ( ) ; } } ; }
Returns an iterator that cycles indefinitely over the elements of {@code iterable}.

<p>The returned iterator supports {@code remove()} if the provided iterator does. After {@code
remove()} is called, subsequent cycles omit the removed element, which is no longer in {@code
iterable}. The iterator's {@code hasNext()} method returns {@code true} until {@code iterable}
is empty.

<p><b>Warning:</b> Typical uses of the resulting iterator may produce an infinite loop. You
should use an explicit {@code break} or be certain that you will eventually remove all the
elements.
Returns an iterator that cycles indefinitely over the elements of { @code iterable } .