code: public static <T> Iterator<T> concat(
        final Iterator<? extends Iterator<? extends T>> inputs) {
      checkNotNull(inputs);
      return new Iterator<T>() {
        Iterator<? extends T> current = emptyIterator();
        Iterator<? extends T> removeFrom;
  
        @Override
        public boolean hasNext() {
          // http://code.google.com/p/google-collections/issues/detail?id=151
          // current.hasNext() might be relatively expensive, worth minimizing.
          boolean currentHasNext;
          // checkNotNull eager for GWT
          // note: it must be here & not where 'current' is assigned,
          // because otherwise we'll have called inputs.next() before throwing
          // the first NPE, and the next time around we'll call inputs.next()
          // again, incorrectly moving beyond the error.
          while (!(currentHasNext = checkNotNull(current).hasNext())
              && inputs.hasNext()) {
            current = inputs.next();
          }
          return currentHasNext;
        }
        @Override
        public T next() {
          if (!hasNext()) {
            throw new NoSuchElementException();
          }
          removeFrom = current;
          return current.next();
        }
        @Override
        public void remove() {
          checkRemove(removeFrom != null);
          removeFrom.remove();
          removeFrom = null;
        }
      };
    }
docs: Combines multiple iterators into a single iterator. The returned iterator
  iterates across the elements of each iterator in {@code inputs}. The input
  iterators are not polled until necessary.
  
  <p>The returned iterator supports {@code remove()} when the corresponding
  input iterator supports it. The methods of the returned iterator may throw
  {@code NullPointerException} if any of the input iterators is null.
  
  <p><b>Note:</b> the current implementation is not suitable for nested
  concatenated iterators, i.e. the following should be avoided when in a loop:
  {@code iterator = Iterators.concat(iterator, suffix);}, since iteration over the
  resulting iterator has a cubic complexity to the depth of the nesting.