IteratorIterate (Eclipse Collections

java.lang.Object
- org.eclipse.collections.impl.utility.internal.IteratorIterate

```
public final class IteratorIterate
extends Object
```
The IteratorIterate class implementations of the various iteration patterns for use with java.util.Iterator.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static <T> Iterator<T>`	`advanceIteratorTo(Iterator<T> iterator, int from)`
`static <T,K,V> MutableMap<K,V>`	`aggregateBy(Iterator<T> iterator, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)`
`static <T,K,V> MutableMap<K,V>`	`aggregateBy(Iterator<T> iterator, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)`
`static <T> boolean`	`allSatisfy(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T,P> boolean`	`allSatisfyWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> boolean`	`anySatisfy(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T,P> boolean`	`anySatisfyWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> RichIterable<RichIterable<T>>`	`chunk(Iterator<T> iterator, int size)`
`static <T,V,R extends Collection<V>> R`	`collect(Iterator<T> iterator, Function<? super T,? extends V> function, R targetCollection)`
`static <T> MutableBooleanCollection`	`collectBoolean(Iterator<T> iterator, BooleanFunction<? super T> booleanFunction)`
`static <T,R extends MutableBooleanCollection> R`	`collectBoolean(Iterator<T> iterator, BooleanFunction<? super T> booleanFunction, R target)`
`static <T> MutableByteCollection`	`collectByte(Iterator<T> iterator, ByteFunction<? super T> byteFunction)`
`static <T,R extends MutableByteCollection> R`	`collectByte(Iterator<T> iterator, ByteFunction<? super T> byteFunction, R target)`
`static <T> MutableCharCollection`	`collectChar(Iterator<T> iterator, CharFunction<? super T> charFunction)`
`static <T,R extends MutableCharCollection> R`	`collectChar(Iterator<T> iterator, CharFunction<? super T> charFunction, R target)`
`static <T> MutableDoubleCollection`	`collectDouble(Iterator<T> iterator, DoubleFunction<? super T> doubleFunction)`
`static <T,R extends MutableDoubleCollection> R`	`collectDouble(Iterator<T> iterator, DoubleFunction<? super T> doubleFunction, R target)`
`static <T> MutableFloatCollection`	`collectFloat(Iterator<T> iterator, FloatFunction<? super T> floatFunction)`
`static <T,R extends MutableFloatCollection> R`	`collectFloat(Iterator<T> iterator, FloatFunction<? super T> floatFunction, R target)`
`static <T,V,R extends Collection<V>> R`	`collectIf(Iterator<T> iterator, Predicate<? super T> predicate, Function<? super T,? extends V> function, R targetCollection)`
`static <T> MutableIntCollection`	`collectInt(Iterator<T> iterator, IntFunction<? super T> intFunction)`
`static <T,R extends MutableIntCollection> R`	`collectInt(Iterator<T> iterator, IntFunction<? super T> intFunction, R target)`
`static <T> MutableLongCollection`	`collectLong(Iterator<T> iterator, LongFunction<? super T> longFunction)`
`static <T,R extends MutableLongCollection> R`	`collectLong(Iterator<T> iterator, LongFunction<? super T> longFunction, R target)`
`static <T> MutableShortCollection`	`collectShort(Iterator<T> iterator, ShortFunction<? super T> shortFunction)`
`static <T,R extends MutableShortCollection> R`	`collectShort(Iterator<T> iterator, ShortFunction<? super T> shortFunction, R target)`
`static <T,P,A,R extends Collection<A>> R`	`collectWith(Iterator<T> iterator, Function2<? super T,? super P,? extends A> function, P parameter, R targetCollection)`
`static <T> int`	`count(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T,P> int`	`countWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> T`	`detect(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T> int`	`detectIndex(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T,IV> int`	`detectIndexWith(Iterator<T> iterator, Predicate2<? super T,? super IV> predicate, IV injectedValue)`
`static <T> Optional<T>`	`detectOptional(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T,P> T`	`detectWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T,P> Optional<T>`	`detectWithOptional(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> MutableList<T>`	`distinct(Iterator<T> iterator)`
`static <T> MutableList<T>`	`distinct(Iterator<T> iterator, HashingStrategy<? super T> hashingStrategy)`
`static <T,R extends List<T>> R`	`distinct(Iterator<T> iterator, R targetCollection)`	Deprecated. in 7.0.
`static <T,R extends MutableCollection<T>> R`	`dropWhile(Iterator<T> iterator, Predicate<? super T> predicate, R target)`
`static <T,V,R extends Collection<V>> R`	`flatCollect(Iterator<T> iterator, Function<? super T,? extends Iterable<V>> function, R targetCollection)`
`static <T> void`	`forEach(Iterator<T> iterator, Procedure<? super T> procedure)`
`static <T,P> void`	`forEachWith(Iterator<T> iterator, Procedure2<? super T,? super P> procedure, P parameter)`
`static <T> void`	`forEachWithIndex(Iterator<T> iterator, ObjectIntProcedure<? super T> objectIntProcedure)`
`static <T,V> ImmutableMultimap<V,T>`	`groupBy(Iterator<T> iterator, Function<? super T,? extends V> function)`
`static <T,V,R extends MutableMultimap<V,T>> R`	`groupBy(Iterator<T> iterator, Function<? super T,? extends V> function, R target)`
`static <T,V,R extends MutableMultimap<V,T>> R`	`groupByEach(Iterator<T> iterator, Function<? super T,? extends Iterable<V>> function, R target)`
`static <K,T,R extends MutableMapIterable<K,T>> R`	`groupByUniqueKey(Iterator<T> iterator, Function<? super T,? extends K> function, R target)`
`static <T> double`	`injectInto(double injectValue, Iterator<T> iterator, DoubleObjectToDoubleFunction<? super T> function)`
`static <T> float`	`injectInto(float injectValue, Iterator<T> iterator, FloatObjectToFloatFunction<? super T> function)`
`static <T> int`	`injectInto(int injectValue, Iterator<T> iterator, IntObjectToIntFunction<? super T> function)`
`static <T> long`	`injectInto(long injectValue, Iterator<T> iterator, LongObjectToLongFunction<? super T> function)`
`static <T,IV> IV`	`injectInto(IV injectValue, Iterator<T> iterator, Function2<? super IV,? super T,? extends IV> function)`
`static <T,IV,P> IV`	`injectIntoWith(IV injectValue, Iterator<T> iterator, Function3<? super IV,? super T,? super P,? extends IV> function, P parameter)`
`static <T> T`	`max(Iterator<T> iterator, Comparator<? super T> comparator)`
`static <T,V extends Comparable<? super V>> T`	`maxBy(Iterator<T> iterator, Function<? super T,? extends V> function)`
`static <T> T`	`min(Iterator<T> iterator, Comparator<? super T> comparator)`
`static <T,V extends Comparable<? super V>> T`	`minBy(Iterator<T> iterator, Function<? super T,? extends V> function)`
`static <T> boolean`	`noneSatisfy(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T,P> boolean`	`noneSatisfyWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T> PartitionMutableList<T>`	`partition(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T,R extends PartitionMutableCollection<T>> R`	`partitionWhile(Iterator<T> iterator, Predicate<? super T> predicate, R target)`
`static <T,P> PartitionMutableList<T>`	`partitionWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T,R extends Collection<T>> R`	`reject(Iterator<T> iterator, Predicate<? super T> predicate, R targetCollection)`
`static <T,P,R extends Collection<T>> R`	`rejectWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)`
`static <T> boolean`	`removeIf(Iterator<T> iterator, Predicate<? super T> predicate)`
`static <T> boolean`	`removeIf(Iterator<T> iterator, Predicate<? super T> predicate, Procedure<? super T> procedure)`
`static <T,P> boolean`	`removeIfWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T,P> boolean`	`removeIfWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter, Procedure<? super T> procedure)`
`static <T,R extends Collection<T>> R`	`select(Iterator<T> iterator, Predicate<? super T> predicate, R targetCollection)`
`static <T,P> Twin<MutableList<T>>`	`selectAndRejectWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P parameter)`
`static <T,R extends Collection<T>> R`	`selectInstancesOf(Iterator<?> iterator, Class<T> clazz, R targetCollection)`
`static <T,P,R extends Collection<T>> R`	`selectWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate, P injectedValue, R targetCollection)`
`static <T> boolean`	`shortCircuit(Iterator<T> iterator, Predicate<? super T> predicate, boolean expected, boolean onShortCircuit, boolean atEnd)`
`static <T,P> boolean`	`shortCircuitWith(Iterator<T> iterator, Predicate2<? super T,? super P> predicate2, P parameter, boolean expected, boolean onShortCircuit, boolean atEnd)`
`static <V,T> MutableMap<V,BigDecimal>`	`sumByBigDecimal(Iterator<T> iterator, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)`
`static <V,T> MutableMap<V,BigInteger>`	`sumByBigInteger(Iterator<T> iterator, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)`
`static <T> BigDecimal`	`sumOfBigDecimal(Iterator<T> iterator, Function<? super T,BigDecimal> function)`
`static <T> BigInteger`	`sumOfBigInteger(Iterator<T> iterator, Function<? super T,BigInteger> function)`
`static <T> double`	`sumOfDouble(Iterator<T> iterator, DoubleFunction<? super T> function)`
`static <T> double`	`sumOfFloat(Iterator<T> iterator, FloatFunction<? super T> function)`
`static <T> long`	`sumOfInt(Iterator<T> iterator, IntFunction<? super T> function)`
`static <T> long`	`sumOfLong(Iterator<T> iterator, LongFunction<? super T> function)`
`static <T,R extends MutableCollection<T>> R`	`takeWhile(Iterator<T> iterator, Predicate<? super T> predicate, R target)`
`static <X,Y,R extends Collection<Pair<X,Y>>> R`	`zip(Iterator<X> xs, Iterator<Y> ys, R target)`
`static <T,R extends Collection<Pair<T,Integer>>> R`	`zipWithIndex(Iterator<T> iterator, R target)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

selectAndRejectWith

public static <T,P> Twin<MutableList<T>> selectAndRejectWith(Iterator<T> iterator,
                                                             Predicate2<? super T,? super P> predicate,
                                                             P parameter)

See Also:: Iterate.selectAndRejectWith(Iterable, Predicate2, Object)

partition

public static <T> PartitionMutableList<T> partition(Iterator<T> iterator,
                                                    Predicate<? super T> predicate)

See Also:: Iterate.partition(Iterable, Predicate)

partitionWith

public static <T,P> PartitionMutableList<T> partitionWith(Iterator<T> iterator,
                                                          Predicate2<? super T,? super P> predicate,
                                                          P parameter)

Since:: 5.0
See Also:: Iterate.partitionWith(Iterable, Predicate2, Object)

partitionWhile

public static <T,R extends PartitionMutableCollection<T>> R partitionWhile(Iterator<T> iterator,
                                                                           Predicate<? super T> predicate,
                                                                           R target)

takeWhile

public static <T,R extends MutableCollection<T>> R takeWhile(Iterator<T> iterator,
                                                             Predicate<? super T> predicate,
                                                             R target)

dropWhile

public static <T,R extends MutableCollection<T>> R dropWhile(Iterator<T> iterator,
                                                             Predicate<? super T> predicate,
                                                             R target)

count

public static <T> int count(Iterator<T> iterator,
                            Predicate<? super T> predicate)

See Also:: Iterate.count(Iterable, Predicate)

countWith

public static <T,P> int countWith(Iterator<T> iterator,
                                  Predicate2<? super T,? super P> predicate,
                                  P parameter)

See Also:: Iterate.countWith(Iterable, Predicate2, Object)

select

public static <T,R extends Collection<T>> R select(Iterator<T> iterator,
                                                   Predicate<? super T> predicate,
                                                   R targetCollection)

See Also:: Iterate.select(Iterable, Predicate, Collection)

selectWith

public static <T,P,R extends Collection<T>> R selectWith(Iterator<T> iterator,
                                                         Predicate2<? super T,? super P> predicate,
                                                         P injectedValue,
                                                         R targetCollection)

See Also:: Iterate.selectWith(Iterable, Predicate2, Object, Collection)

selectInstancesOf

public static <T,R extends Collection<T>> R selectInstancesOf(Iterator<?> iterator,
                                                              Class<T> clazz,
                                                              R targetCollection)

See Also:: Iterate.selectInstancesOf(Iterable, Class)

collectIf

public static <T,V,R extends Collection<V>> R collectIf(Iterator<T> iterator,
                                                        Predicate<? super T> predicate,
                                                        Function<? super T,? extends V> function,
                                                        R targetCollection)

See Also:: Iterate.selectWith(Iterable, Predicate2, Object, Collection)

reject

public static <T,R extends Collection<T>> R reject(Iterator<T> iterator,
                                                   Predicate<? super T> predicate,
                                                   R targetCollection)

See Also:: Iterate.reject(Iterable, Predicate, Collection)

rejectWith

public static <T,P,R extends Collection<T>> R rejectWith(Iterator<T> iterator,
                                                         Predicate2<? super T,? super P> predicate,
                                                         P parameter,
                                                         R targetCollection)

See Also:: Iterate.rejectWith(Iterable, Predicate2, Object, Collection)

collect

public static <T,V,R extends Collection<V>> R collect(Iterator<T> iterator,
                                                      Function<? super T,? extends V> function,
                                                      R targetCollection)

See Also:: Iterate.collect(Iterable, Function, Collection)

collectBoolean

public static <T> MutableBooleanCollection collectBoolean(Iterator<T> iterator,
                                                          BooleanFunction<? super T> booleanFunction)

See Also:: Iterate.collectBoolean(Iterable, BooleanFunction)

collectBoolean

public static <T,R extends MutableBooleanCollection> R collectBoolean(Iterator<T> iterator,
                                                                      BooleanFunction<? super T> booleanFunction,
                                                                      R target)

See Also:: Iterate.collectBoolean(Iterable, BooleanFunction, MutableBooleanCollection)

collectByte

public static <T> MutableByteCollection collectByte(Iterator<T> iterator,
                                                    ByteFunction<? super T> byteFunction)

See Also:: Iterate.collectByte(Iterable, ByteFunction)

collectByte

public static <T,R extends MutableByteCollection> R collectByte(Iterator<T> iterator,
                                                                ByteFunction<? super T> byteFunction,
                                                                R target)

See Also:: Iterate.collectByte(Iterable, ByteFunction, MutableByteCollection)

collectChar

public static <T> MutableCharCollection collectChar(Iterator<T> iterator,
                                                    CharFunction<? super T> charFunction)

See Also:: Iterate.collectChar(Iterable, CharFunction)

collectChar

public static <T,R extends MutableCharCollection> R collectChar(Iterator<T> iterator,
                                                                CharFunction<? super T> charFunction,
                                                                R target)

See Also:: Iterate.collectChar(Iterable, CharFunction, MutableCharCollection)

collectDouble

public static <T> MutableDoubleCollection collectDouble(Iterator<T> iterator,
                                                        DoubleFunction<? super T> doubleFunction)

See Also:: Iterate.collectDouble(Iterable, DoubleFunction)

collectDouble

public static <T,R extends MutableDoubleCollection> R collectDouble(Iterator<T> iterator,
                                                                    DoubleFunction<? super T> doubleFunction,
                                                                    R target)

See Also:: Iterate.collectDouble(Iterable, DoubleFunction, MutableDoubleCollection)

collectFloat

public static <T> MutableFloatCollection collectFloat(Iterator<T> iterator,
                                                      FloatFunction<? super T> floatFunction)

See Also:: Iterate.collectFloat(Iterable, FloatFunction)

collectFloat

public static <T,R extends MutableFloatCollection> R collectFloat(Iterator<T> iterator,
                                                                  FloatFunction<? super T> floatFunction,
                                                                  R target)

See Also:: Iterate.collectFloat(Iterable, FloatFunction, MutableFloatCollection)

collectInt

public static <T> MutableIntCollection collectInt(Iterator<T> iterator,
                                                  IntFunction<? super T> intFunction)

See Also:: Iterate.collectInt(Iterable, IntFunction)

collectInt

public static <T,R extends MutableIntCollection> R collectInt(Iterator<T> iterator,
                                                              IntFunction<? super T> intFunction,
                                                              R target)

See Also:: Iterate.collectInt(Iterable, IntFunction, MutableIntCollection)

collectLong

public static <T> MutableLongCollection collectLong(Iterator<T> iterator,
                                                    LongFunction<? super T> longFunction)

See Also:: Iterate.collectLong(Iterable, LongFunction)

collectLong

public static <T,R extends MutableLongCollection> R collectLong(Iterator<T> iterator,
                                                                LongFunction<? super T> longFunction,
                                                                R target)

See Also:: Iterate.collectLong(Iterable, LongFunction, MutableLongCollection)

collectShort

public static <T> MutableShortCollection collectShort(Iterator<T> iterator,
                                                      ShortFunction<? super T> shortFunction)

See Also:: Iterate.collectShort(Iterable, ShortFunction)

collectShort

public static <T,R extends MutableShortCollection> R collectShort(Iterator<T> iterator,
                                                                  ShortFunction<? super T> shortFunction,
                                                                  R target)

See Also:: Iterate.collectShort(Iterable, ShortFunction, MutableShortCollection)

flatCollect

public static <T,V,R extends Collection<V>> R flatCollect(Iterator<T> iterator,
                                                          Function<? super T,? extends Iterable<V>> function,
                                                          R targetCollection)

See Also:: Iterate.flatCollect(Iterable, Function, Collection)

forEach

public static <T> void forEach(Iterator<T> iterator,
                               Procedure<? super T> procedure)

See Also:: Iterate.forEach(Iterable, Procedure)

forEachWithIndex

public static <T> void forEachWithIndex(Iterator<T> iterator,
                                        ObjectIntProcedure<? super T> objectIntProcedure)

See Also:: Iterate.forEachWithIndex(Iterable, ObjectIntProcedure)

detect

public static <T> T detect(Iterator<T> iterator,
                           Predicate<? super T> predicate)

See Also:: Iterate.detect(Iterable, Predicate)

detectWith

public static <T,P> T detectWith(Iterator<T> iterator,
                                 Predicate2<? super T,? super P> predicate,
                                 P parameter)

See Also:: Iterate.detectWith(Iterable, Predicate2, Object)

detectOptional

public static <T> Optional<T> detectOptional(Iterator<T> iterator,
                                             Predicate<? super T> predicate)

See Also:: Iterate.detectOptional(Iterable, Predicate)

detectWithOptional

public static <T,P> Optional<T> detectWithOptional(Iterator<T> iterator,
                                                   Predicate2<? super T,? super P> predicate,
                                                   P parameter)

See Also:: Iterate.detectWithOptional(Iterable, Predicate2, Object)

injectInto

public static <T,IV> IV injectInto(IV injectValue,
                                   Iterator<T> iterator,
                                   Function2<? super IV,? super T,? extends IV> function)

See Also:: Iterate.injectInto(Object, Iterable, Function2)

injectInto

public static <T> int injectInto(int injectValue,
                                 Iterator<T> iterator,
                                 IntObjectToIntFunction<? super T> function)

See Also:: Iterate.injectInto(int, Iterable, IntObjectToIntFunction)

injectInto

public static <T> long injectInto(long injectValue,
                                  Iterator<T> iterator,
                                  LongObjectToLongFunction<? super T> function)

See Also:: Iterate.injectInto(long, Iterable, LongObjectToLongFunction)

injectInto

public static <T> double injectInto(double injectValue,
                                    Iterator<T> iterator,
                                    DoubleObjectToDoubleFunction<? super T> function)

See Also:: Iterate.injectInto(double, Iterable, DoubleObjectToDoubleFunction)

injectInto

public static <T> float injectInto(float injectValue,
                                   Iterator<T> iterator,
                                   FloatObjectToFloatFunction<? super T> function)

See Also:: Iterate.injectInto(float, Iterable, FloatObjectToFloatFunction)

injectIntoWith

public static <T,IV,P> IV injectIntoWith(IV injectValue,
                                         Iterator<T> iterator,
                                         Function3<? super IV,? super T,? super P,? extends IV> function,
                                         P parameter)

See Also:: Iterate.injectIntoWith(Object, Iterable, Function3, Object)

shortCircuit

public static <T> boolean shortCircuit(Iterator<T> iterator,
                                       Predicate<? super T> predicate,
                                       boolean expected,
                                       boolean onShortCircuit,
                                       boolean atEnd)

shortCircuitWith

public static <T,P> boolean shortCircuitWith(Iterator<T> iterator,
                                             Predicate2<? super T,? super P> predicate2,
                                             P parameter,
                                             boolean expected,
                                             boolean onShortCircuit,
                                             boolean atEnd)

anySatisfy

public static <T> boolean anySatisfy(Iterator<T> iterator,
                                     Predicate<? super T> predicate)

See Also:: Iterate.anySatisfy(Iterable, Predicate)

anySatisfyWith

public static <T,P> boolean anySatisfyWith(Iterator<T> iterator,
                                           Predicate2<? super T,? super P> predicate,
                                           P parameter)

See Also:: Iterate.anySatisfyWith(Iterable, Predicate2, Object)

allSatisfy

public static <T> boolean allSatisfy(Iterator<T> iterator,
                                     Predicate<? super T> predicate)

See Also:: Iterate.allSatisfy(Iterable, Predicate)

allSatisfyWith

public static <T,P> boolean allSatisfyWith(Iterator<T> iterator,
                                           Predicate2<? super T,? super P> predicate,
                                           P parameter)

See Also:: Iterate.allSatisfyWith(Iterable, Predicate2, Object)

noneSatisfy

public static <T> boolean noneSatisfy(Iterator<T> iterator,
                                      Predicate<? super T> predicate)

See Also:: Iterate.noneSatisfy(Iterable, Predicate)

noneSatisfyWith

public static <T,P> boolean noneSatisfyWith(Iterator<T> iterator,
                                            Predicate2<? super T,? super P> predicate,
                                            P parameter)

See Also:: Iterate.noneSatisfyWith(Iterable, Predicate2, Object)

removeIf

public static <T> boolean removeIf(Iterator<T> iterator,
                                   Predicate<? super T> predicate)

See Also:: Iterate.removeIf(Iterable, Predicate)

removeIfWith

public static <T,P> boolean removeIfWith(Iterator<T> iterator,
                                         Predicate2<? super T,? super P> predicate,
                                         P parameter)

See Also:: Iterate.removeIfWith(Iterable, Predicate2, Object)

removeIf

public static <T> boolean removeIf(Iterator<T> iterator,
                                   Predicate<? super T> predicate,
                                   Procedure<? super T> procedure)

removeIfWith

public static <T,P> boolean removeIfWith(Iterator<T> iterator,
                                         Predicate2<? super T,? super P> predicate,
                                         P parameter,
                                         Procedure<? super T> procedure)

detectIndex

public static <T> int detectIndex(Iterator<T> iterator,
                                  Predicate<? super T> predicate)

See Also:: Iterate.detectIndex(Iterable, Predicate)

detectIndexWith

public static <T,IV> int detectIndexWith(Iterator<T> iterator,
                                         Predicate2<? super T,? super IV> predicate,
                                         IV injectedValue)

See Also:: Iterate.detectIndexWith(Iterable, Predicate2, Object)

forEachWith

public static <T,P> void forEachWith(Iterator<T> iterator,
                                     Procedure2<? super T,? super P> procedure,
                                     P parameter)

See Also:: Iterate.forEachWith(Iterable, Procedure2, Object)

collectWith

public static <T,P,A,R extends Collection<A>> R collectWith(Iterator<T> iterator,
                                                            Function2<? super T,? super P,? extends A> function,
                                                            P parameter,
                                                            R targetCollection)

See Also:: Iterate.collectWith(Iterable, Function2, Object, Collection)

groupBy

public static <T,V> ImmutableMultimap<V,T> groupBy(Iterator<T> iterator,
                                                   Function<? super T,? extends V> function)

See Also:: Iterate.groupBy(Iterable, Function)

groupBy

public static <T,V,R extends MutableMultimap<V,T>> R groupBy(Iterator<T> iterator,
                                                             Function<? super T,? extends V> function,
                                                             R target)

See Also:: Iterate.groupBy(Iterable, Function, MutableMultimap)

groupByEach

public static <T,V,R extends MutableMultimap<V,T>> R groupByEach(Iterator<T> iterator,
                                                                 Function<? super T,? extends Iterable<V>> function,
                                                                 R target)

See Also:: Iterate.groupByEach(Iterable, Function, MutableMultimap)

groupByUniqueKey

public static <K,T,R extends MutableMapIterable<K,T>> R groupByUniqueKey(Iterator<T> iterator,
                                                                         Function<? super T,? extends K> function,
                                                                         R target)

See Also:: Iterate.groupByUniqueKey(Iterable, Function, MutableMapIterable)

distinct

@Deprecated
public static <T,R extends List<T>> R distinct(Iterator<T> iterator,
                                               R targetCollection)

Deprecated. in 7.0.

distinct

public static <T> MutableList<T> distinct(Iterator<T> iterator)

Since:: 7.0.

distinct

public static <T> MutableList<T> distinct(Iterator<T> iterator,
                                          HashingStrategy<? super T> hashingStrategy)

Since:: 7.0.

zip

public static <X,Y,R extends Collection<Pair<X,Y>>> R zip(Iterator<X> xs,
                                                          Iterator<Y> ys,
                                                          R target)

See Also:: Iterate.zip(Iterable, Iterable, Collection)

zipWithIndex

public static <T,R extends Collection<Pair<T,Integer>>> R zipWithIndex(Iterator<T> iterator,
                                                                       R target)

See Also:: Iterate.zipWithIndex(Iterable, Collection)

chunk

public static <T> RichIterable<RichIterable<T>> chunk(Iterator<T> iterator,
                                                      int size)

See Also:: Iterate.chunk(Iterable, int)

min

public static <T> T min(Iterator<T> iterator,
                        Comparator<? super T> comparator)

See Also:: Iterate.min(Iterable, Comparator)

max

public static <T> T max(Iterator<T> iterator,
                        Comparator<? super T> comparator)

See Also:: Iterate.max(Iterable, Comparator)

advanceIteratorTo

public static <T> Iterator<T> advanceIteratorTo(Iterator<T> iterator,
                                                int from)

sumOfInt

public static <T> long sumOfInt(Iterator<T> iterator,
                                IntFunction<? super T> function)

sumOfLong

public static <T> long sumOfLong(Iterator<T> iterator,
                                 LongFunction<? super T> function)

sumOfFloat

public static <T> double sumOfFloat(Iterator<T> iterator,
                                    FloatFunction<? super T> function)

sumOfDouble

public static <T> double sumOfDouble(Iterator<T> iterator,
                                     DoubleFunction<? super T> function)

sumOfBigDecimal

public static <T> BigDecimal sumOfBigDecimal(Iterator<T> iterator,
                                             Function<? super T,BigDecimal> function)

sumOfBigInteger

public static <T> BigInteger sumOfBigInteger(Iterator<T> iterator,
                                             Function<? super T,BigInteger> function)

sumByBigDecimal

public static <V,T> MutableMap<V,BigDecimal> sumByBigDecimal(Iterator<T> iterator,
                                                             Function<? super T,? extends V> groupBy,
                                                             Function<? super T,BigDecimal> function)

sumByBigInteger

public static <V,T> MutableMap<V,BigInteger> sumByBigInteger(Iterator<T> iterator,
                                                             Function<? super T,? extends V> groupBy,
                                                             Function<? super T,BigInteger> function)

aggregateBy

public static <T,K,V> MutableMap<K,V> aggregateBy(Iterator<T> iterator,
                                                  Function<? super T,? extends K> groupBy,
                                                  Function0<? extends V> zeroValueFactory,
                                                  Procedure2<? super V,? super T> mutatingAggregator)

aggregateBy

public static <T,K,V> MutableMap<K,V> aggregateBy(Iterator<T> iterator,
                                                  Function<? super T,? extends K> groupBy,
                                                  Function0<? extends V> zeroValueFactory,
                                                  Function2<? super V,? super T,? extends V> nonMutatingAggregator)

minBy

public static <T,V extends Comparable<? super V>> T minBy(Iterator<T> iterator,
                                                          Function<? super T,? extends V> function)

maxBy

public static <T,V extends Comparable<? super V>> T maxBy(Iterator<T> iterator,
                                                          Function<? super T,? extends V> function)

Class IteratorIterate

Method Summary

Methods inherited from class java.lang.Object

Method Detail

selectAndRejectWith

partition

partitionWith

partitionWhile

takeWhile

dropWhile

count

countWith

select

selectWith

selectInstancesOf

collectIf

reject

rejectWith

collect

collectBoolean

collectBoolean

collectByte

collectByte

collectChar

collectChar

collectDouble

collectDouble

collectFloat

collectFloat

collectInt

collectInt

collectLong

collectLong

collectShort

collectShort

flatCollect

forEach

forEachWithIndex

detect

detectWith

detectOptional

detectWithOptional

injectInto

injectInto

injectInto

injectInto

injectInto

injectIntoWith

shortCircuit

shortCircuitWith

anySatisfy

anySatisfyWith

allSatisfy

allSatisfyWith

noneSatisfy

noneSatisfyWith

removeIf

removeIfWith

removeIf

removeIfWith

detectIndex

detectIndexWith

forEachWith

collectWith

groupBy

groupBy

groupByEach

groupByUniqueKey

distinct

distinct

distinct

zip

zipWithIndex

chunk

min

max

advanceIteratorTo

sumOfInt

sumOfLong

sumOfFloat