com.gs.collections.impl.bag

Class AbstractBag<T>

java.lang.Object

com.gs.collections.impl.AbstractRichIterable<T>

com.gs.collections.impl.bag.AbstractBag<T>

All Implemented Interfaces:

com.gs.collections.api.bag.Bag<T>, com.gs.collections.api.InternalIterable<T>, com.gs.collections.api.RichIterable<T>, java.lang.Iterable<T>, java.util.Collection<T>

Direct Known Subclasses:

AbstractImmutableBagIterable, AbstractMutableBagIterable

public abstract class AbstractBag<T>
extends AbstractRichIterable<T>
implements java.util.Collection<T>, com.gs.collections.api.bag.Bag<T>

Since:

7.0

Constructor Summary

Constructors

Constructor and Description
AbstractBag()

Method Summary

Methods

Modifier and Type	Method and Description
<V,R extends java.util.Collection<V>> R	collect(com.gs.collections.api.block.function.Function<? super T,? extends V> function, R target) Same as RichIterable.collect(Function), except that the results are gathered into the specified target collection.
<R extends com.gs.collections.api.collection.primitive.MutableBooleanCollection> R	collectBoolean(com.gs.collections.api.block.function.primitive.BooleanFunction<? super T> booleanFunction, R target) Same as RichIterable.collectBoolean(BooleanFunction), except that the results are gathered into the specified target collection.
<R extends com.gs.collections.api.collection.primitive.MutableByteCollection> R	collectByte(com.gs.collections.api.block.function.primitive.ByteFunction<? super T> byteFunction, R target) Same as RichIterable.collectByte(ByteFunction), except that the results are gathered into the specified target collection.
<R extends com.gs.collections.api.collection.primitive.MutableCharCollection> R	collectChar(com.gs.collections.api.block.function.primitive.CharFunction<? super T> charFunction, R target) Same as RichIterable.collectChar(CharFunction), except that the results are gathered into the specified target collection.
<R extends com.gs.collections.api.collection.primitive.MutableDoubleCollection> R	collectDouble(com.gs.collections.api.block.function.primitive.DoubleFunction<? super T> doubleFunction, R target) Same as RichIterable.collectDouble(DoubleFunction), except that the results are gathered into the specified target collection.
<R extends com.gs.collections.api.collection.primitive.MutableFloatCollection> R	collectFloat(com.gs.collections.api.block.function.primitive.FloatFunction<? super T> floatFunction, R target) Same as RichIterable.collectFloat(FloatFunction), except that the results are gathered into the specified target collection.
<V,R extends java.util.Collection<V>> R	collectIf(com.gs.collections.api.block.predicate.Predicate<? super T> predicate, com.gs.collections.api.block.function.Function<? super T,? extends V> function, R target) Same as the collectIf method with two parameters but uses the specified target collection for the results.
<R extends com.gs.collections.api.collection.primitive.MutableIntCollection> R	collectInt(com.gs.collections.api.block.function.primitive.IntFunction<? super T> intFunction, R target) Same as RichIterable.collectInt(IntFunction), except that the results are gathered into the specified target collection.
<R extends com.gs.collections.api.collection.primitive.MutableLongCollection> R	collectLong(com.gs.collections.api.block.function.primitive.LongFunction<? super T> longFunction, R target) Same as RichIterable.collectLong(LongFunction), except that the results are gathered into the specified target collection.
<R extends com.gs.collections.api.collection.primitive.MutableShortCollection> R	collectShort(com.gs.collections.api.block.function.primitive.ShortFunction<? super T> shortFunction, R target) Same as RichIterable.collectShort(ShortFunction), except that the results are gathered into the specified target collection.
<P,V,R extends java.util.Collection<V>> R	collectWith(com.gs.collections.api.block.function.Function2<? super T,? super P,? extends V> function, P parameter, R target) Same as collectWith but with a targetCollection parameter to gather the results.
int	count(com.gs.collections.api.block.predicate.Predicate<? super T> predicate) Return the total number of elements that answer true to the specified predicate.
<V,R extends java.util.Collection<V>> R	flatCollect(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function, R target) Same as flatCollect, only the results are collected into the target collection.
<V,R extends com.gs.collections.api.multimap.MutableMultimap<V,T>> R	groupBy(com.gs.collections.api.block.function.Function<? super T,? extends V> function, R target) Same as RichIterable.groupBy(Function), except that the results are gathered into the specified target multimap.
<V,R extends com.gs.collections.api.multimap.MutableMultimap<V,T>> R	groupByEach(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function, R target) Same as RichIterable.groupByEach(Function), except that the results are gathered into the specified target multimap.
double	injectInto(double injectedValue, com.gs.collections.api.block.function.primitive.DoubleObjectToDoubleFunction<? super T> function) Returns the final double result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
float	injectInto(float injectedValue, com.gs.collections.api.block.function.primitive.FloatObjectToFloatFunction<? super T> function) Returns the final float result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
int	injectInto(int injectedValue, com.gs.collections.api.block.function.primitive.IntObjectToIntFunction<? super T> function) Returns the final int result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
<IV> IV	injectInto(IV injectedValue, com.gs.collections.api.block.function.Function2<? super IV,? super T,? extends IV> function) Returns the final result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
long	injectInto(long injectedValue, com.gs.collections.api.block.function.primitive.LongObjectToLongFunction<? super T> function) Returns the final long result of evaluating function using each element of the iterable and the previous evaluation result as the parameters.
<IV,P> IV	injectIntoWith(IV injectedValue, com.gs.collections.api.block.function.Function3<? super IV,? super T,? super P,? extends IV> function, P parameter)
protected com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>>	occurrencesSortingBy(int n, com.gs.collections.api.block.function.primitive.IntFunction<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> function, com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> returnWhenEmpty)
<R extends java.util.Collection<T>> R	reject(com.gs.collections.api.block.predicate.Predicate<? super T> predicate, R target) Same as the reject method with one parameter but uses the specified target collection for the results.
<P,R extends java.util.Collection<T>> R	rejectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate, P parameter, R target) Similar to RichIterable.reject(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.
<R extends java.util.Collection<T>> R	select(com.gs.collections.api.block.predicate.Predicate<? super T> predicate, R target) Same as the select method with one parameter but uses the specified target collection for the results.
<P,R extends java.util.Collection<T>> R	selectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate, P parameter, R target) Similar to RichIterable.select(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.
double	sumOfDouble(com.gs.collections.api.block.function.primitive.DoubleFunction<? super T> function) Returns the final double result of evaluating function for each element of the iterable and adding the results together.
double	sumOfFloat(com.gs.collections.api.block.function.primitive.FloatFunction<? super T> function) Returns the final double result of evaluating function for each element of the iterable and adding the results together.
long	sumOfInt(com.gs.collections.api.block.function.primitive.IntFunction<? super T> function) Returns the final long result of evaluating function for each element of the iterable and adding the results together.
long	sumOfLong(com.gs.collections.api.block.function.primitive.LongFunction<? super T> function) Returns the final long result of evaluating function for each element of the iterable and adding the results together.
com.gs.collections.api.bag.MutableBag<T>	toBag() Converts the collection to the default MutableBag implementation.
com.gs.collections.api.list.MutableList<T>	toList() Converts the collection to a MutableList implementation.
protected com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>>	toListWithOccurrences()
com.gs.collections.api.set.MutableSet<T>	toSet() Converts the collection to a MutableSet implementation.
com.gs.collections.api.bag.sorted.MutableSortedBag<T>	toSortedBag() Converts the collection to a MutableSortedBag implementation and sorts it using the natural order of the elements.
com.gs.collections.api.bag.sorted.MutableSortedBag<T>	toSortedBag(java.util.Comparator<? super T> comparator) Converts the collection to the MutableSortedBag implementation and sorts it using the specified comparator.
com.gs.collections.api.list.MutableList<T>	toSortedList(java.util.Comparator<? super T> comparator) Converts the collection to a MutableList implementation and sorts it using the specified comparator.
com.gs.collections.api.set.sorted.MutableSortedSet<T>	toSortedSet() Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the elements.
com.gs.collections.api.set.sorted.MutableSortedSet<T>	toSortedSet(java.util.Comparator<? super T> comparator) Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.
java.lang.String	toStringOfItemToCount() Returns a string representation of this bag.

Methods inherited from class com.gs.collections.impl.AbstractRichIterable

allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, contains, containsAll, containsAllArguments, containsAllIterable, countWith, detect, detectIfNone, detectWith, detectWithIfNone, forEach, forEachWith, forEachWithIndex, groupByUniqueKey, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, sumByDouble, sumByFloat, sumByInt, sumByLong, toArray, toArray, toMap, toSortedBagBy, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSetBy, toString, zip, zipWithIndex

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Collection

add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray

Methods inherited from interface com.gs.collections.api.bag.Bag

bottomOccurrences, equals, forEachWithOccurrences, groupBy, groupByEach, hashCode, occurrencesOf, partition, partitionWith, reject, rejectWith, select, selectByOccurrences, selectInstancesOf, selectWith, sizeDistinct, tap, toImmutable, toMapOfItemToCount, topOccurrences, zipWithIndex

Methods inherited from interface com.gs.collections.api.RichIterable

aggregateBy, aggregateInPlaceBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, countWith, detect, detectIfNone, detectWith, detectWithIfNone, each, flatCollect, getFirst, getLast, groupByUniqueKey, groupByUniqueKey, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, size, sumByDouble, sumByFloat, sumByInt, sumByLong, toArray, toArray, toMap, toSortedBagBy, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSetBy, toString, zip, zip, zipWithIndex

Methods inherited from interface com.gs.collections.api.InternalIterable

forEach, forEachWith, forEachWithIndex

Constructor Detail

AbstractBag

public AbstractBag()

Method Detail

select

public <R extends java.util.Collection<T>> R select(com.gs.collections.api.block.predicate.Predicate<? super T> predicate,
                                           R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as the select method with one parameter but uses the specified target collection for the results.

Example using a Java 8 lambda expression:

 MutableList<Person> selected =
     people.select(person -> person.person.getLastName().equals("Smith"), Lists.mutable.empty());
 

Example using an anonymous inner class:

 MutableList<Person> selected =
     people.select(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.person.getLastName().equals("Smith");
         }
     }, Lists.mutable.empty());
 

Specified by:

select in interface com.gs.collections.api.RichIterable<T>

Overrides:

select in class AbstractRichIterable<T>

Parameters:

predicate - a Predicate to use as the select criteria

target - the Collection to append to for all elements in this RichIterable that meet select criteria predicate

Returns:

target, which contains appended elements as a result of the select criteria

See Also:

RichIterable.select(Predicate)

selectWith

public <P,R extends java.util.Collection<T>> R selectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate,
                                                 P parameter,
                                                 R target)

Description copied from interface: com.gs.collections.api.RichIterable

Similar to RichIterable.select(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.

E.g. return a Collection of Person elements where the person has an age greater than or equal to 18 years

Example using a Java 8 lambda expression:

 MutableList<Person> selected =
     people.selectWith((Person person, Integer age) -> person.getAge() >= age, Integer.valueOf(18), Lists.mutable.empty());
 

Example using an anonymous inner class:

 MutableList<Person> selected =
     people.selectWith(new Predicate2<Person, Integer>()
     {
         public boolean accept(Person person, Integer age)
         {
             return person.getAge() >= age;
         }
     }, Integer.valueOf(18), Lists.mutable.empty());
 

Specified by:

selectWith in interface com.gs.collections.api.RichIterable<T>

Overrides:

selectWith in class AbstractRichIterable<T>

Parameters:

predicate - a Predicate2 to use as the select criteria

parameter - a parameter to pass in for evaluation of the second argument P in predicate

target - the Collection to append to for all elements in this RichIterable that meet select criteria predicate

Returns:

targetCollection, which contains appended elements as a result of the select criteria

See Also:

RichIterable.select(Predicate), RichIterable.select(Predicate, Collection)

reject

public <R extends java.util.Collection<T>> R reject(com.gs.collections.api.block.predicate.Predicate<? super T> predicate,
                                           R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as the reject method with one parameter but uses the specified target collection for the results.

Example using a Java 8 lambda expression:

 MutableList<Person> rejected =
     people.reject(person -> person.person.getLastName().equals("Smith"), Lists.mutable.empty());
 

Example using an anonymous inner class:

 MutableList<Person> rejected =
     people.reject(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.person.getLastName().equals("Smith");
         }
     }, Lists.mutable.empty());
 

Specified by:

reject in interface com.gs.collections.api.RichIterable<T>

Overrides:

reject in class AbstractRichIterable<T>

Parameters:

predicate - a Predicate to use as the reject criteria

target - the Collection to append to for all elements in this RichIterable that cause Predicate#accept(Object) method to evaluate to false

Returns:

target, which contains appended elements as a result of the reject criteria

rejectWith

public <P,R extends java.util.Collection<T>> R rejectWith(com.gs.collections.api.block.predicate.Predicate2<? super T,? super P> predicate,
                                                 P parameter,
                                                 R target)

Description copied from interface: com.gs.collections.api.RichIterable

Similar to RichIterable.reject(Predicate, Collection), except with an evaluation parameter for the second generic argument in Predicate2.

E.g. return a Collection of Person elements where the person has an age greater than or equal to 18 years

Example using a Java 8 lambda expression:

 MutableList<Person> rejected =
     people.rejectWith((Person person, Integer age) -> person.getAge() < age, Integer.valueOf(18), Lists.mutable.empty());
 

Example using an anonymous inner class:

 MutableList<Person> rejected =
     people.rejectWith(new Predicate2<Person, Integer>()
     {
         public boolean accept(Person person, Integer age)
         {
             return person.getAge() < age;
         }
     }, Integer.valueOf(18), Lists.mutable.empty());
 

Specified by:

rejectWith in interface com.gs.collections.api.RichIterable<T>

Overrides:

rejectWith in class AbstractRichIterable<T>

Parameters:

predicate - a Predicate2 to use as the reject criteria

parameter - a parameter to pass in for evaluation of the second argument P in predicate

target - the Collection to append to for all elements in this RichIterable that cause Predicate#accept(Object) method to evaluate to false

Returns:

targetCollection, which contains appended elements as a result of the reject criteria

See Also:

RichIterable.reject(Predicate), RichIterable.reject(Predicate, Collection)

count

public int count(com.gs.collections.api.block.predicate.Predicate<? super T> predicate)

Description copied from interface: com.gs.collections.api.RichIterable

Return the total number of elements that answer true to the specified predicate.

Example using a Java 8 lambda expression:

 int count =
     people.count(person -> person.getAddress().getState().getName().equals("New York"));
 

Example using an anonymous inner class:

 int count =
     people.count(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.getAddress().getState().getName().equals("New York");
         }
     });
 

Specified by:

count in interface com.gs.collections.api.RichIterable<T>

Overrides:

count in class AbstractRichIterable<T>

collect

public <V,R extends java.util.Collection<V>> R collect(com.gs.collections.api.block.function.Function<? super T,? extends V> function,
                                              R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collect(Function), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 MutableList<String> names =
     people.collect(person -> person.getFirstName() + " " + person.getLastName(), Lists.mutable.empty());
 

Example using an anonymous inner class:

 MutableList<String> names =
     people.collect(new Function<Person, String>()
     {
         public String valueOf(Person person)
         {
             return person.getFirstName() + " " + person.getLastName();
         }
     }, Lists.mutable.empty());
 

Specified by:

collect in interface com.gs.collections.api.RichIterable<T>

Overrides:

collect in class AbstractRichIterable<T>

Parameters:

function - a Function to use as the collect transformation function

target - the Collection to append to for all elements in this RichIterable that meet select criteria function

Returns:

target, which contains appended elements as a result of the collect transformation

See Also:

RichIterable.collect(Function)

collectWith

public <P,V,R extends java.util.Collection<V>> R collectWith(com.gs.collections.api.block.function.Function2<? super T,? super P,? extends V> function,
                                                    P parameter,
                                                    R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as collectWith but with a targetCollection parameter to gather the results.

Example using a Java 8 lambda expression:

 MutableSet<Integer> integers =
     Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1), Sets.mutable.empty());
 

Example using an anonymous inner class:

 Function2 addParameterFunction =
     new Function2()
     {
         public Integer value(final Integer each, final Integer parameter)
         {
             return each + parameter;
         }
     };
 MutableSet<Integer> integers =
     Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1), Sets.mutable.empty());
 

Specified by:

collectWith in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectWith in class AbstractRichIterable<T>

Parameters:

function - a Function2 to use as the collect transformation function

parameter - a parameter to pass in for evaluation of the second argument P in function

target - the Collection to append to for all elements in this RichIterable that meet select criteria function

Returns:

targetCollection, which contains appended elements as a result of the collect transformation

collectIf

public <V,R extends java.util.Collection<V>> R collectIf(com.gs.collections.api.block.predicate.Predicate<? super T> predicate,
                                                com.gs.collections.api.block.function.Function<? super T,? extends V> function,
                                                R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as the collectIf method with two parameters but uses the specified target collection for the results.

Specified by:

collectIf in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectIf in class AbstractRichIterable<T>

Parameters:

predicate - a Predicate to use as the select criteria

function - a Function to use as the collect transformation function

target - the Collection to append to for all elements in this RichIterable that meet the collect criteria predicate

Returns:

targetCollection, which contains appended elements as a result of the collect criteria and transformation

See Also:

RichIterable.collectIf(Predicate, Function)

flatCollect

public <V,R extends java.util.Collection<V>> R flatCollect(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function,
                                                  R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as flatCollect, only the results are collected into the target collection.

Specified by:

flatCollect in interface com.gs.collections.api.RichIterable<T>

Overrides:

flatCollect in class AbstractRichIterable<T>

Parameters:

function - The Function to apply

target - The collection into which results should be added.

Returns:

target, which will contain a flattened collection of results produced by applying the given function

See Also:

RichIterable.flatCollect(Function)

collectBoolean

public <R extends com.gs.collections.api.collection.primitive.MutableBooleanCollection> R collectBoolean(com.gs.collections.api.block.function.primitive.BooleanFunction<? super T> booleanFunction,
                                                                                                R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectBoolean(BooleanFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 BooleanArrayList licenses =
     people.collectBoolean(person -> person.hasDrivingLicense(), new BooleanArrayList());
 

Example using an anonymous inner class:

 BooleanArrayList licenses =
     people.collectBoolean(new BooleanFunction<Person>()
     {
         public boolean booleanValueOf(Person person)
         {
             return person.hasDrivingLicense();
         }
     }, new BooleanArrayList());
 

Specified by:

collectBoolean in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectBoolean in class AbstractRichIterable<T>

Parameters:

booleanFunction - a BooleanFunction to use as the collect transformation function

target - the MutableBooleanCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

collectByte

public <R extends com.gs.collections.api.collection.primitive.MutableByteCollection> R collectByte(com.gs.collections.api.block.function.primitive.ByteFunction<? super T> byteFunction,
                                                                                          R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectByte(ByteFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 ByteArrayList bytes =
     people.collectByte(person -> person.getCode(), new ByteArrayList());
 

Example using an anonymous inner class:

 ByteArrayList bytes =
     people.collectByte(new ByteFunction<Person>()
     {
         public byte byteValueOf(Person person)
         {
             return person.getCode();
         }
     }, new ByteArrayList());
 

Specified by:

collectByte in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectByte in class AbstractRichIterable<T>

Parameters:

byteFunction - a ByteFunction to use as the collect transformation function

target - the MutableByteCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

collectChar

public <R extends com.gs.collections.api.collection.primitive.MutableCharCollection> R collectChar(com.gs.collections.api.block.function.primitive.CharFunction<? super T> charFunction,
                                                                                          R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectChar(CharFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 CharArrayList chars =
     people.collectChar(person -> person.getMiddleInitial(), new CharArrayList());
 

Example using an anonymous inner class:

 CharArrayList chars =
     people.collectChar(new CharFunction<Person>()
     {
         public char charValueOf(Person person)
         {
             return person.getMiddleInitial();
         }
     }, new CharArrayList());
 

Specified by:

collectChar in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectChar in class AbstractRichIterable<T>

Parameters:

charFunction - a CharFunction to use as the collect transformation function

target - the MutableCharCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

collectDouble

public <R extends com.gs.collections.api.collection.primitive.MutableDoubleCollection> R collectDouble(com.gs.collections.api.block.function.primitive.DoubleFunction<? super T> doubleFunction,
                                                                                              R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectDouble(DoubleFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 DoubleArrayList doubles =
     people.collectDouble(person -> person.getMilesFromNorthPole(), new DoubleArrayList());
 

Example using an anonymous inner class:

 DoubleArrayList doubles =
     people.collectDouble(new DoubleFunction<Person>()
     {
         public double doubleValueOf(Person person)
         {
             return person.getMilesFromNorthPole();
         }
     }, new DoubleArrayList());
 

Specified by:

collectDouble in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectDouble in class AbstractRichIterable<T>

Parameters:

doubleFunction - a DoubleFunction to use as the collect transformation function

target - the MutableDoubleCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

collectFloat

public <R extends com.gs.collections.api.collection.primitive.MutableFloatCollection> R collectFloat(com.gs.collections.api.block.function.primitive.FloatFunction<? super T> floatFunction,
                                                                                            R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectFloat(FloatFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 FloatArrayList floats =
     people.collectFloat(person -> person.getHeightInInches(), new FloatArrayList());
 

Example using an anonymous inner class:

 FloatArrayList floats =
     people.collectFloat(new FloatFunction<Person>()
     {
         public float floatValueOf(Person person)
         {
             return person.getHeightInInches();
         }
     }, new FloatArrayList());
 

Specified by:

collectFloat in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectFloat in class AbstractRichIterable<T>

Parameters:

floatFunction - a FloatFunction to use as the collect transformation function

target - the MutableFloatCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

collectInt

public <R extends com.gs.collections.api.collection.primitive.MutableIntCollection> R collectInt(com.gs.collections.api.block.function.primitive.IntFunction<? super T> intFunction,
                                                                                        R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectInt(IntFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 IntArrayList ints =
     people.collectInt(person -> person.getAge(), new IntArrayList());
 

Example using an anonymous inner class:

 IntArrayList ints =
     people.collectInt(new IntFunction<Person>()
     {
         public int intValueOf(Person person)
         {
             return person.getAge();
         }
     }, new IntArrayList());
 

Specified by:

collectInt in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectInt in class AbstractRichIterable<T>

Parameters:

intFunction - a IntFunction to use as the collect transformation function

target - the MutableIntCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

collectLong

public <R extends com.gs.collections.api.collection.primitive.MutableLongCollection> R collectLong(com.gs.collections.api.block.function.primitive.LongFunction<? super T> longFunction,
                                                                                          R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectLong(LongFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 LongArrayList longs =
     people.collectLong(person -> person.getGuid(), new LongArrayList());
 

Example using an anonymous inner class:

 LongArrayList longs =
     people.collectLong(new LongFunction<Person>()
     {
         public long longValueOf(Person person)
         {
             return person.getGuid();
         }
     }, new LongArrayList());
 

Specified by:

collectLong in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectLong in class AbstractRichIterable<T>

Parameters:

longFunction - a LongFunction to use as the collect transformation function

target - the MutableLongCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

collectShort

public <R extends com.gs.collections.api.collection.primitive.MutableShortCollection> R collectShort(com.gs.collections.api.block.function.primitive.ShortFunction<? super T> shortFunction,
                                                                                            R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.collectShort(ShortFunction), except that the results are gathered into the specified target collection.

Example using a Java 8 lambda expression:

 ShortArrayList shorts =
     people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth, new ShortArrayList());
 

Example using an anonymous inner class:

 ShortArrayList shorts =
     people.collectShort(new ShortFunction<Person>()
     {
         public short shortValueOf(Person person)
         {
             return person.getNumberOfJunkMailItemsReceivedPerMonth;
         }
     }, new ShortArrayList());
 

Specified by:

collectShort in interface com.gs.collections.api.RichIterable<T>

Overrides:

collectShort in class AbstractRichIterable<T>

Parameters:

shortFunction - a ShortFunction to use as the collect transformation function

target - the MutableShortCollection to append to for all elements in this RichIterable

Returns:

target, which contains appended elements as a result of the collect transformation

groupBy

public <V,R extends com.gs.collections.api.multimap.MutableMultimap<V,T>> R groupBy(com.gs.collections.api.block.function.Function<? super T,? extends V> function,
                                                                           R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.groupBy(Function), except that the results are gathered into the specified target multimap.

Example using a Java 8 method reference:

 FastListMultimap<String, Person> peopleByLastName =
     people.groupBy(Person::getLastName, new FastListMultimap<String, Person>());
 

Example using an anonymous inner class:

 FastListMultimap<String, Person> peopleByLastName =
     people.groupBy(new Function<Person, String>()
     {
         public String value(Person person)
         {
             return person.getLastName();
         }
     }, new FastListMultimap<String, Person>());
 

Specified by:

groupBy in interface com.gs.collections.api.RichIterable<T>

Overrides:

groupBy in class AbstractRichIterable<T>

groupByEach

public <V,R extends com.gs.collections.api.multimap.MutableMultimap<V,T>> R groupByEach(com.gs.collections.api.block.function.Function<? super T,? extends java.lang.Iterable<V>> function,
                                                                               R target)

Description copied from interface: com.gs.collections.api.RichIterable

Same as RichIterable.groupByEach(Function), except that the results are gathered into the specified target multimap.

Specified by:

groupByEach in interface com.gs.collections.api.RichIterable<T>

Overrides:

groupByEach in class AbstractRichIterable<T>

sumOfInt

public long sumOfInt(com.gs.collections.api.block.function.primitive.IntFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final long result of evaluating function for each element of the iterable and adding the results together.

Specified by:

sumOfInt in interface com.gs.collections.api.RichIterable<T>

Overrides:

sumOfInt in class AbstractRichIterable<T>

sumOfFloat

public double sumOfFloat(com.gs.collections.api.block.function.primitive.FloatFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final double result of evaluating function for each element of the iterable and adding the results together. It uses Kahan summation algorithm to reduce numerical error.

Specified by:

sumOfFloat in interface com.gs.collections.api.RichIterable<T>

Overrides:

sumOfFloat in class AbstractRichIterable<T>

sumOfLong

public long sumOfLong(com.gs.collections.api.block.function.primitive.LongFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final long result of evaluating function for each element of the iterable and adding the results together.

Specified by:

sumOfLong in interface com.gs.collections.api.RichIterable<T>

Overrides:

sumOfLong in class AbstractRichIterable<T>

sumOfDouble

public double sumOfDouble(com.gs.collections.api.block.function.primitive.DoubleFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final double result of evaluating function for each element of the iterable and adding the results together. It uses Kahan summation algorithm to reduce numerical error.

Specified by:

sumOfDouble in interface com.gs.collections.api.RichIterable<T>

Overrides:

sumOfDouble in class AbstractRichIterable<T>

injectInto

public <IV> IV injectInto(IV injectedValue,
                 com.gs.collections.api.block.function.Function2<? super IV,? super T,? extends IV> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter. This method is commonly called fold or sometimes reduce.

Specified by:

injectInto in interface com.gs.collections.api.RichIterable<T>

Overrides:

injectInto in class AbstractRichIterable<T>

injectInto

public int injectInto(int injectedValue,
             com.gs.collections.api.block.function.primitive.IntObjectToIntFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final int result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Specified by:

injectInto in interface com.gs.collections.api.RichIterable<T>

Overrides:

injectInto in class AbstractRichIterable<T>

injectInto

public long injectInto(long injectedValue,
              com.gs.collections.api.block.function.primitive.LongObjectToLongFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final long result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Specified by:

injectInto in interface com.gs.collections.api.RichIterable<T>

Overrides:

injectInto in class AbstractRichIterable<T>

injectInto

public double injectInto(double injectedValue,
                com.gs.collections.api.block.function.primitive.DoubleObjectToDoubleFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final double result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Specified by:

injectInto in interface com.gs.collections.api.RichIterable<T>

Overrides:

injectInto in class AbstractRichIterable<T>

injectInto

public float injectInto(float injectedValue,
               com.gs.collections.api.block.function.primitive.FloatObjectToFloatFunction<? super T> function)

Description copied from interface: com.gs.collections.api.RichIterable

Returns the final float result of evaluating function using each element of the iterable and the previous evaluation result as the parameters. The injected value is used for the first parameter of the first evaluation, and the current item in the iterable is used as the second parameter.

Specified by:

injectInto in interface com.gs.collections.api.RichIterable<T>

Overrides:

injectInto in class AbstractRichIterable<T>

injectIntoWith

public <IV,P> IV injectIntoWith(IV injectedValue,
                       com.gs.collections.api.block.function.Function3<? super IV,? super T,? super P,? extends IV> function,
                       P parameter)

toStringOfItemToCount

public java.lang.String toStringOfItemToCount()

Description copied from interface: com.gs.collections.api.bag.Bag

Returns a string representation of this bag. The string representation consists of a list of element-count mappings. The elements each appear once, in an order consistent with other methods like Bag.forEachWithOccurrences(ObjectIntProcedure) and Iterable.iterator(). The element-count mappings are enclosed in braces ("{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each element-count mapping is rendered as the element followed by an equals sign ("=") followed by the number of ooccurrences. Elements and are converted to strings as by String.valueOf(Object).

The string representation is similar to AbstractMap.toString(), not RichIterable.toString().

Specified by:

toStringOfItemToCount in interface com.gs.collections.api.bag.Bag<T>

Returns:

a string representation of this bag

toListWithOccurrences

protected com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> toListWithOccurrences()

toList

public com.gs.collections.api.list.MutableList<T> toList()

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to a MutableList implementation.

Specified by:

toList in interface com.gs.collections.api.RichIterable<T>

Overrides:

toList in class AbstractRichIterable<T>

toSortedList

public com.gs.collections.api.list.MutableList<T> toSortedList(java.util.Comparator<? super T> comparator)

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to a MutableList implementation and sorts it using the specified comparator.

Specified by:

toSortedList in interface com.gs.collections.api.RichIterable<T>

Overrides:

toSortedList in class AbstractRichIterable<T>

toSet

public com.gs.collections.api.set.MutableSet<T> toSet()

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to a MutableSet implementation.

Specified by:

toSet in interface com.gs.collections.api.RichIterable<T>

Overrides:

toSet in class AbstractRichIterable<T>

toSortedSet

public com.gs.collections.api.set.sorted.MutableSortedSet<T> toSortedSet()

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the elements.

Specified by:

toSortedSet in interface com.gs.collections.api.RichIterable<T>

Overrides:

toSortedSet in class AbstractRichIterable<T>

toSortedSet

public com.gs.collections.api.set.sorted.MutableSortedSet<T> toSortedSet(java.util.Comparator<? super T> comparator)

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to a MutableSortedSet implementation and sorts it using the specified comparator.

Specified by:

toSortedSet in interface com.gs.collections.api.RichIterable<T>

Overrides:

toSortedSet in class AbstractRichIterable<T>

toBag

public com.gs.collections.api.bag.MutableBag<T> toBag()

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to the default MutableBag implementation.

Specified by:

toBag in interface com.gs.collections.api.RichIterable<T>

Overrides:

toBag in class AbstractRichIterable<T>

toSortedBag

public com.gs.collections.api.bag.sorted.MutableSortedBag<T> toSortedBag()

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to a MutableSortedBag implementation and sorts it using the natural order of the elements.

Specified by:

toSortedBag in interface com.gs.collections.api.RichIterable<T>

Overrides:

toSortedBag in class AbstractRichIterable<T>

toSortedBag

public com.gs.collections.api.bag.sorted.MutableSortedBag<T> toSortedBag(java.util.Comparator<? super T> comparator)

Description copied from interface: com.gs.collections.api.RichIterable

Converts the collection to the MutableSortedBag implementation and sorts it using the specified comparator.

Specified by:

toSortedBag in interface com.gs.collections.api.RichIterable<T>

Overrides:

toSortedBag in class AbstractRichIterable<T>

occurrencesSortingBy

protected com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> occurrencesSortingBy(int n,
                                                                                                                    com.gs.collections.api.block.function.primitive.IntFunction<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> function,
                                                                                                                    com.gs.collections.api.list.MutableList<com.gs.collections.api.tuple.primitive.ObjectIntPair<T>> returnWhenEmpty)