How to use

java.util.Iterator

constructor

Iterator<Integer> powersOfTwo = new AbstractSequentialIterator<Integer>(1) { // note the initial value!
  protected Integer computeNext(Integer previous) {
   return (previous == 1 << 30) ? null : previous * 2;
  }
 };

 public Iterator<T> iterator(int index) {
  Iterator<T> it = new DoublelinkedlistIterator();
  for (int i = 0; i < index && it.hasNext(); i++, it.next());
  return it;
}

 import org.neo4j.graphdb.*;
import org.neo4j.helpers.Predicate;
import org.neo4j.helpers.collection.FilteringIterator;

...

try (ResourceIterator<Node> nodes = 
  graphDatabaseService.findNodes(DynamicLabel.label("LABEL1"))) {

  Iterator<Node> nodeWithAllLabels = new FilteringIterator<>(nodes,
      node -> node.hasLabel(DynamicLabel.label("LABEL2")) && 
          node.hasLabel(DynamicLabel.label("LABEL3"))
  );

  // do stuff with nodeWithAllLabels
}

 public Iterator<E> iterator(int x){

  Iterator<E> it = new ListIterator();

  for (; x > 0; --x){
    it.next(); 
  }
  return it;
}

 Iterator<Choice> iter = new list.iterator();
while iterator.hasNext(){
  iter.next().add( option );
}

 Iterator<String> di = new MyDoublyIterator<String>(); 
di.hasPrev();

 public Iterator<E> iterator(int x) {
  if (x < 0 || this.size() < x) {
    throw new IndexOutOfBoundsException();
  }

  Iterator<E> it = new ListIterator();

  for (; x > 0; --x) {
    it.next(); // ignore the first x values
  }
  return it;
}

 List<String[]> input = Arrays.asList(
  new String[] {"such", "nice", "question"},
  new String[] {"much", "iterator"},
  new String[] {"very", "wow"}
);
Iterator<Collection<String>> it = new CombinatorIterator(input);
it.forEachRemaining(System.out::println);

 List<String> jedis = asList("Obiwan","Yoda","Luke");
List<String> siths = asList("Lord Sidious", "Darth Mul", "Darth Vader");
List<String> padawans = asList("Anakin", "Jarjar", "Poncho");

Iterator<Triplet> iter = new TripletIterator(jedis, siths, padawans);
while(iter.hasNext()){
  Triplet t = iter.next();
  System.out.println(t);
}

 Iterator<Point> pointIterator = new PointParser();
Spliterator<Point> pointSpliterator = Spliterators.spliteratorUnknownSize(pointIterator, Spliterator.IMMUTABLE | Spliterator.NONNULL);
Set<Point> result = StreamSupport.stream(pointSpliterator, true)
  .filter(this::withinDistance)
  .collect(Collectors.toSet());

 public <T> LinkedList<T> sort(LinkedList<T> list){
  Iterator<T> iter = new list.iterator();
  while (iter.hasNext()){
    T t = iter.next();
    ...
  }
}

public static final Iterator<Integer> RAND_INT_ITER =
 new AbstractIterator<Integer>() {
   @Override
   protected Integer computeNext() {
     return ThreadLocalRandom.current().nextInt();
   }
 };

 final Iterator<Integer> series = new AbstractLinkedIterator<Integer>(100) {

  @Override protected Integer computeNext(final Integer previous) {
    return previous == 80 ? null : previous - 1;
  }
};
while (series.hasNext()) {
  System.out.println(series.next());
}

 Iterator<Long> i = new Counter(0, 50);
while (i.hasNext()) {
  System.out.println(i.next());  // Prints 0 to 50
}

 int i = 0;
Iterator<Kid> it = new ArrayIterator<>(kids);
StringBuffer sb = new StringBuffer();
while (it.hasNext()) {
  Kid kid = it.next();
  if (!kid.hasToy()) continue;
  sb.append(++i).append(".").append(kid.getSurname());
  if (it.hasNext()) {
    sb.append(", ");
  }
}

 List<List<Integer>> elements = Arrays.asList(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
Iterator<List<Integer>> combinations = new Combinations<>(elements);
combinations.forEachRemaining(System.out::println);

 String s = "1 56 123 30 0";

Iterator<Double> it = new DoubleIterator(new ByteArrayInputStream(s.getBytes()));
while(it.hasNext()) {
  System.out.println(it.next());
}
it = new NoiseIterator(new DoubleIterator(new ByteArrayInputStream(s.getBytes())));
while(it.hasNext()) {
  System.out.println(it.next());
}

 List<String> strings = Arrays.asList( "1","2","3" ) ;

// Create our mapping Iterator
Iterator<Integer> iter = new Collector<>( strings, new Mapper<String,Integer>() {
  @Override
  public Integer apply( String v ) {
    return Integer.parseInt( v ) * 2 ;
  }
} ) ;

// Collect back from iterator into a List
List<Integer> numbers = new ArrayList<>() ;
while( iter.hasNext() ) {
  numbers.add( iter.next() ) ;
}

 Predicate<Object[]> predicate = new Predicate<>() {
          evaluate(Object[] obj) { 
             return (obj[2].equals("Closed")); 
          }
        };

Iterator<Object[]> filteredIterator = new FilterIterator<>(
              resultList.iterator, 
              predicate
            );

 Iterator sheetInterator = new Itertor();
Set<Object> set = new HashSet();
while(sheetInterator.hasNext()) { 
  Row myrow = (Row) obj.next();
  Iterator rowIterator = myrow.iterator();
  while(rowIterator.hasNext()) {
    Cell cell = (Cell) rowIterator.next();
    String value = cell.getValue();
    if(!set.add(value)){
      // value has not been added to the set -> it is at least 2nd occurrence of this value 
    }
  }
}