code: public static <T> ObjIterator<T> skip(final Iterator<T> iter, final long n) {
          N.checkArgNotNegative(n, "n");
  
          if (iter == null || n == 0) {
              return ObjIterator.of(iter);
          }
  
          return new ObjIterator<T>() {
              private boolean skipped = false;
  
              @Override
              public boolean hasNext() {
                  if (skipped == false) {
                      skip();
                  }
  
                  return iter.hasNext();
              }
  
              @Override
              public T next() {
                  if (hasNext() == false) {
                      throw new NoSuchElementException();
                  }
  
                  return iter.next();
              }
  
              private void skip() {
                  long idx = 0;
  
                  while (idx++ < n && iter.hasNext()) {
                      iter.next();
                  }
  
                  skipped = true;
              }
          };
      }
docs: Calls {@code next()} on {@code iterator}, either {@code n} times
  or until {@code hasNext()} returns {@code false}, whichever comes first.
  
  This is a lazy evaluation operation. The {@code skip} action is only triggered when {@code Iterator.hasNext()} or {@code Iterator.next()} is called.
  
  @param iter
  @param n
  @return