java.lang.Iterable<T>, java.util.Collection<T>, Bag<T>, InternalIterable<T>, RichIterable<T>AbstractImmutableBagIterable, AbstractMutableBagIterablepublic abstract class AbstractBag<T> extends AbstractRichIterable<T> implements java.util.Collection<T>, Bag<T>
| Constructor | Description |
|---|---|
AbstractBag() |
| Modifier and Type | Method | Description |
|---|---|---|
<V,R extends java.util.Collection<V>> |
collect(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 MutableBooleanCollection> |
collectBoolean(BooleanFunction<? super T> booleanFunction,
R target) |
Same as
RichIterable.collectBoolean(BooleanFunction), except that the results are gathered into the specified target
collection. |
<R extends MutableByteCollection> |
collectByte(ByteFunction<? super T> byteFunction,
R target) |
Same as
RichIterable.collectByte(ByteFunction), except that the results are gathered into the specified target
collection. |
<R extends MutableCharCollection> |
collectChar(CharFunction<? super T> charFunction,
R target) |
Same as
RichIterable.collectChar(CharFunction), except that the results are gathered into the specified target
collection. |
<R extends MutableDoubleCollection> |
collectDouble(DoubleFunction<? super T> doubleFunction,
R target) |
Same as
RichIterable.collectDouble(DoubleFunction), except that the results are gathered into the specified target
collection. |
<R extends MutableFloatCollection> |
collectFloat(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>> |
collectIf(Predicate<? super T> predicate,
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 MutableIntCollection> |
collectInt(IntFunction<? super T> intFunction,
R target) |
Same as
RichIterable.collectInt(IntFunction), except that the results are gathered into the specified target
collection. |
<R extends MutableLongCollection> |
collectLong(LongFunction<? super T> longFunction,
R target) |
Same as
RichIterable.collectLong(LongFunction), except that the results are gathered into the specified target
collection. |
<R extends MutableShortCollection> |
collectShort(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>> |
collectWith(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(Predicate<? super T> predicate) |
Return the total number of elements that answer true to the specified predicate.
|
<V,R extends java.util.Collection<V>> |
flatCollect(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 MutableMultimap<V,T>> |
groupBy(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 MutableMultimap<V,T>> |
groupByEach(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,
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,
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,
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.
|
long |
injectInto(long injectedValue,
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> IV |
injectInto(IV injectedValue,
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.
|
<IV,P> IV |
injectIntoWith(IV injectedValue,
Function3<? super IV,? super T,? super P,? extends IV> function,
P parameter) |
|
<R extends java.util.Collection<T>> |
reject(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>> |
rejectWith(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>> |
select(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>> |
selectWith(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(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(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(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(LongFunction<? super T> function) |
Returns the final long result of evaluating function for each element of the iterable and adding the results
together.
|
MutableBag<T> |
toBag() |
Converts the collection to the default MutableBag implementation.
|
MutableList<T> |
toList() |
Converts the collection to a MutableList implementation.
|
MutableSet<T> |
toSet() |
Converts the collection to a MutableSet implementation.
|
MutableSortedBag<T> |
toSortedBag() |
Converts the collection to a MutableSortedBag implementation and sorts it using the natural order of the
elements.
|
MutableSortedBag<T> |
toSortedBag(java.util.Comparator<? super T> comparator) |
Converts the collection to the MutableSortedBag implementation and sorts it using the specified comparator.
|
MutableList<T> |
toSortedList(java.util.Comparator<? super T> comparator) |
Converts the collection to a MutableList implementation and sorts it using the specified comparator.
|
MutableSortedSet<T> |
toSortedSet() |
Converts the collection to a MutableSortedSet implementation and sorts it using the natural order of the
elements.
|
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.
|
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, asLazy, contains, containsAll, containsAllArguments, containsAllIterable, countBy, countByWith, countWith, detect, detectOptional, detectWith, detectWithIfNone, detectWithOptional, forEach, forEachWith, forEachWithIndex, groupByUniqueKey, into, isEmpty, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, toArray, toArray, toMap, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedSetBy, toString, zip, zipWithIndexbottomOccurrences, collectWithOccurrences, equals, forEachWithOccurrences, groupBy, groupByEach, hashCode, occurrencesOf, partition, partitionWith, reduceInPlace, reduceInPlace, reject, rejectWith, select, selectByOccurrences, selectInstancesOf, selectWith, sizeDistinct, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, tap, toImmutable, toMapOfItemToCount, topOccurrences, zipWithIndexadd, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, stream, toArray, toArrayforEach, forEachWith, forEachWithIndexequals, getClass, hashCode, notify, notifyAll, wait, wait, waitaggregateBy, 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, countBy, countBy, countByWith, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, getFirst, getLast, getOnly, groupByUniqueKey, groupByUniqueKey, into, isEmpty, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, reduce, size, sumByDouble, sumByFloat, sumByInt, sumByLong, toArray, toArray, toMap, toSortedBagBy, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSetBy, toString, zip, zip, zipWithIndexpublic <R extends java.util.Collection<T>> R select(Predicate<? super T> predicate, R target)
RichIterableExample 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());
select in interface RichIterable<T>select in class AbstractRichIterable<T>predicate - a Predicate to use as the select criteriatarget - the Collection to append to for all elements in this RichIterable that meet select criteria predicatetarget, which contains appended elements as a result of the select criteriaRichIterable.select(Predicate)public <P,R extends java.util.Collection<T>> R selectWith(Predicate2<? super T,? super P> predicate, P parameter, R target)
RichIterableRichIterable.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());
selectWith in interface RichIterable<T>selectWith in class AbstractRichIterable<T>predicate - a Predicate2 to use as the select criteriaparameter - a parameter to pass in for evaluation of the second argument P in predicatetarget - the Collection to append to for all elements in this RichIterable that meet select criteria predicatetargetCollection, which contains appended elements as a result of the select criteriaRichIterable.select(Predicate),
RichIterable.select(Predicate, Collection)public <R extends java.util.Collection<T>> R reject(Predicate<? super T> predicate, R target)
RichIterableExample 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());
reject in interface RichIterable<T>reject in class AbstractRichIterable<T>predicate - a Predicate to use as the reject criteriatarget - the Collection to append to for all elements in this RichIterable that cause Predicate#accept(Object) method to evaluate to falsetarget, which contains appended elements as a result of the reject criteriapublic <P,R extends java.util.Collection<T>> R rejectWith(Predicate2<? super T,? super P> predicate, P parameter, R target)
RichIterableRichIterable.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());
rejectWith in interface RichIterable<T>rejectWith in class AbstractRichIterable<T>predicate - a Predicate2 to use as the reject criteriaparameter - a parameter to pass in for evaluation of the second argument P in predicatetarget - the Collection to append to for all elements in this RichIterable that cause Predicate#accept(Object) method to evaluate to falsetargetCollection, which contains appended elements as a result of the reject criteriaRichIterable.reject(Predicate),
RichIterable.reject(Predicate, Collection)public int count(Predicate<? super T> predicate)
RichIterableExample 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");
}
});
count in interface RichIterable<T>count in class AbstractRichIterable<T>public <V,R extends java.util.Collection<V>> R collect(Function<? super T,? extends V> function, R target)
RichIterableRichIterable.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());
collect in interface RichIterable<T>collect in class AbstractRichIterable<T>function - a Function to use as the collect transformation functiontarget - the Collection to append to for all elements in this RichIterable that meet select criteria functiontarget, which contains appended elements as a result of the collect transformationRichIterable.collect(Function)public <P,V,R extends java.util.Collection<V>> R collectWith(Function2<? super T,? super P,? extends V> function, P parameter, R target)
RichIterableExample 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<Integer, Integer, Integer> addParameterFunction =
new Function2<Integer, Integer, Integer>()
{
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());
collectWith in interface RichIterable<T>collectWith in class AbstractRichIterable<T>function - a Function2 to use as the collect transformation functionparameter - a parameter to pass in for evaluation of the second argument P in functiontarget - the Collection to append to for all elements in this RichIterable that meet select criteria functiontargetCollection, which contains appended elements as a result of the collect transformationpublic <V,R extends java.util.Collection<V>> R collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function, R target)
RichIterablecollectIf in interface RichIterable<T>collectIf in class AbstractRichIterable<T>predicate - a Predicate to use as the select criteriafunction - a Function to use as the collect transformation functiontarget - the Collection to append to for all elements in this RichIterable that meet the collect criteria predicatetargetCollection, which contains appended elements as a result of the collect criteria and transformationRichIterable.collectIf(Predicate, Function)public <V,R extends java.util.Collection<V>> R flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function, R target)
RichIterableflatCollect in interface RichIterable<T>flatCollect in class AbstractRichIterable<T>function - The Function to applytarget - The collection into which results should be added.target, which will contain a flattened collection of results produced by applying the given functionRichIterable.flatCollect(Function)public <R extends MutableBooleanCollection> R collectBoolean(BooleanFunction<? super T> booleanFunction, R target)
RichIterableRichIterable.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());
collectBoolean in interface RichIterable<T>collectBoolean in class AbstractRichIterable<T>booleanFunction - a BooleanFunction to use as the collect transformation functiontarget - the MutableBooleanCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <R extends MutableByteCollection> R collectByte(ByteFunction<? super T> byteFunction, R target)
RichIterableRichIterable.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());
collectByte in interface RichIterable<T>collectByte in class AbstractRichIterable<T>byteFunction - a ByteFunction to use as the collect transformation functiontarget - the MutableByteCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <R extends MutableCharCollection> R collectChar(CharFunction<? super T> charFunction, R target)
RichIterableRichIterable.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());
collectChar in interface RichIterable<T>collectChar in class AbstractRichIterable<T>charFunction - a CharFunction to use as the collect transformation functiontarget - the MutableCharCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <R extends MutableDoubleCollection> R collectDouble(DoubleFunction<? super T> doubleFunction, R target)
RichIterableRichIterable.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());
collectDouble in interface RichIterable<T>collectDouble in class AbstractRichIterable<T>doubleFunction - a DoubleFunction to use as the collect transformation functiontarget - the MutableDoubleCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <R extends MutableFloatCollection> R collectFloat(FloatFunction<? super T> floatFunction, R target)
RichIterableRichIterable.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());
collectFloat in interface RichIterable<T>collectFloat in class AbstractRichIterable<T>floatFunction - a FloatFunction to use as the collect transformation functiontarget - the MutableFloatCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <R extends MutableIntCollection> R collectInt(IntFunction<? super T> intFunction, R target)
RichIterableRichIterable.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());
collectInt in interface RichIterable<T>collectInt in class AbstractRichIterable<T>intFunction - a IntFunction to use as the collect transformation functiontarget - the MutableIntCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <R extends MutableLongCollection> R collectLong(LongFunction<? super T> longFunction, R target)
RichIterableRichIterable.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());
collectLong in interface RichIterable<T>collectLong in class AbstractRichIterable<T>longFunction - a LongFunction to use as the collect transformation functiontarget - the MutableLongCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <R extends MutableShortCollection> R collectShort(ShortFunction<? super T> shortFunction, R target)
RichIterableRichIterable.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());
collectShort in interface RichIterable<T>collectShort in class AbstractRichIterable<T>shortFunction - a ShortFunction to use as the collect transformation functiontarget - the MutableShortCollection to append to for all elements in this RichIterabletarget, which contains appended elements as a result of the collect transformationpublic <V,R extends MutableMultimap<V,T>> R groupBy(Function<? super T,? extends V> function, R target)
RichIterableRichIterable.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 valueOf(Person person)
{
return person.getLastName();
}
}, new FastListMultimap<String, Person>());
groupBy in interface RichIterable<T>groupBy in class AbstractRichIterable<T>public <V,R extends MutableMultimap<V,T>> R groupByEach(Function<? super T,? extends java.lang.Iterable<V>> function, R target)
RichIterableRichIterable.groupByEach(Function), except that the results are gathered into the specified target
multimap.groupByEach in interface RichIterable<T>groupByEach in class AbstractRichIterable<T>public long sumOfInt(IntFunction<? super T> function)
RichIterablesumOfInt in interface RichIterable<T>sumOfInt in class AbstractRichIterable<T>public double sumOfFloat(FloatFunction<? super T> function)
RichIterablesumOfFloat in interface RichIterable<T>sumOfFloat in class AbstractRichIterable<T>public long sumOfLong(LongFunction<? super T> function)
RichIterablesumOfLong in interface RichIterable<T>sumOfLong in class AbstractRichIterable<T>public double sumOfDouble(DoubleFunction<? super T> function)
RichIterablesumOfDouble in interface RichIterable<T>sumOfDouble in class AbstractRichIterable<T>public <IV> IV injectInto(IV injectedValue,
Function2<? super IV,? super T,? extends IV> function)
RichIterableinjectInto in interface RichIterable<T>injectInto in class AbstractRichIterable<T>public int injectInto(int injectedValue,
IntObjectToIntFunction<? super T> function)
RichIterableinjectInto in interface RichIterable<T>injectInto in class AbstractRichIterable<T>public long injectInto(long injectedValue,
LongObjectToLongFunction<? super T> function)
RichIterableinjectInto in interface RichIterable<T>injectInto in class AbstractRichIterable<T>public double injectInto(double injectedValue,
DoubleObjectToDoubleFunction<? super T> function)
RichIterableinjectInto in interface RichIterable<T>injectInto in class AbstractRichIterable<T>public float injectInto(float injectedValue,
FloatObjectToFloatFunction<? super T> function)
RichIterableinjectInto in interface RichIterable<T>injectInto in class AbstractRichIterable<T>public <IV,P> IV injectIntoWith(IV injectedValue,
Function3<? super IV,? super T,? super P,? extends IV> function,
P parameter)
public java.lang.String toStringOfItemToCount()
Bag
Assert.assertEquals("{1=1, 2=2, 3=3}", Bags.mutable.with(1, 2, 2, 3, 3, 3).toStringOfItemToCount());
This string representation is similar to AbstractMap.toString(), not RichIterable.toString(),
whereas the toString() implementation for a Bag is consistent with RichIterable.toString().toStringOfItemToCount in interface Bag<T>public MutableList<T> toList()
RichIterabletoList in interface RichIterable<T>toList in class AbstractRichIterable<T>public MutableList<T> toSortedList(java.util.Comparator<? super T> comparator)
RichIterabletoSortedList in interface RichIterable<T>public MutableSet<T> toSet()
RichIterabletoSet in interface RichIterable<T>toSet in class AbstractRichIterable<T>public MutableSortedSet<T> toSortedSet()
RichIterabletoSortedSet in interface RichIterable<T>toSortedSet in class AbstractRichIterable<T>public MutableSortedSet<T> toSortedSet(java.util.Comparator<? super T> comparator)
RichIterabletoSortedSet in interface RichIterable<T>toSortedSet in class AbstractRichIterable<T>public MutableBag<T> toBag()
RichIterabletoBag in interface RichIterable<T>toBag in class AbstractRichIterable<T>public MutableSortedBag<T> toSortedBag()
RichIterabletoSortedBag in interface RichIterable<T>toSortedBag in class AbstractRichIterable<T>public MutableSortedBag<T> toSortedBag(java.util.Comparator<? super T> comparator)
RichIterabletoSortedBag in interface RichIterable<T>toSortedBag in class AbstractRichIterable<T>Copyright © 2004–2018. All rights reserved.