code: 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();
        }
      };
    }
docs: 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.