code: public static <T> Iterator<T> concat(
  			final Iterator<? extends Iterator<? extends T>> inputs) {
  		checkNotNull(inputs);
  		return new Iterator<T>() {
  			Iterator<? extends T> current = Collections.<T>emptyList().iterator();
  			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() {
  				checkState(removeFrom != null,
  						"no calls to next() since last call to remove()");
  				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.