Package org.eclipse.collections.impl.utility.internal

Class IteratorIterate

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

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)