| Modifier and Type | Method and Description |
|---|---|
| public default <K, VV> MutableMap | aggregateBy(Function<? super V, ? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV, ? super V, ? extends VV> nonMutatingAggregator)
Overrides default org. Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. |
| public <K, VV> MutableMap | aggregateInPlaceBy(Function<? super V, ? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV, ? super V> mutatingAggregator)
Redeclares as abstract: org. Applies an aggregate procedure over the iterable grouping results into a Map based on the specific groupBy function. |
| public void | |
| public <VV> MutableBag | collect(Function<? super V, ? extends VV> function)
Redeclares org. Returns a new collection with the results of applying the specified function on each element of the source collection. |
| public MutableBooleanBag | collectBoolean(BooleanFunction<? super V> booleanFunction)
Redeclares org. Returns a new primitive |
| public MutableByteBag | collectByte(ByteFunction<? super V> byteFunction)
Redeclares org. Returns a new primitive |
| public MutableCharBag | collectChar(CharFunction<? super V> charFunction)
Redeclares org. Returns a new primitive |
| public MutableDoubleBag | collectDouble(DoubleFunction<? super V> doubleFunction)
Redeclares org. Returns a new primitive |
| public MutableFloatBag | collectFloat(FloatFunction<? super V> floatFunction)
Redeclares org. Returns a new primitive |
| public <VV> MutableBag | collectIf(Predicate<? super V> predicate, Function<? super V, ? extends VV> function)
Redeclares org. Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate. |
| public MutableIntBag | collectInt(IntFunction<? super V> intFunction)
Redeclares org. Returns a new primitive |
| public MutableLongBag | collectLong(LongFunction<? super V> longFunction)
Redeclares org. Returns a new primitive |
| public MutableShortBag | collectShort(ShortFunction<? super V> shortFunction)
Redeclares org. Returns a new primitive |
| public <P, VV> MutableBag | collectWith(Function2<? super V, ? super P, ? extends VV> function, P parameter)
Redeclares org. Same as |
| public <VV> MutableBag | flatCollect(Function<? super V, ? extends Iterable<VV>> function)
Redeclares org.
|
| public default <P, VV> MutableBag | flatCollectWith(Function2<? super V, ? super P, ? extends Iterable<VV>> function, P parameter)
Overrides default org. Same as flatCollect, only with a Function2 that is passed an extra parameter. |
| public <VV> MutableBagMultimap | groupBy(Function<? super V, ? extends VV> function)
Redeclares org. For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable. |
| public <VV> MutableBagMultimap | groupByEach(Function<? super V, ? extends Iterable<VV>> function)
Redeclares org. Similar to |
| public default <VV> MutableMap | groupByUniqueKey(Function<? super V, ? extends VV> function)
Implements org. For each element of the iterable, the function is evaluated, and the results of these evaluations are collected into a new map, where the transformed value is the key. |
| public PartitionMutableBag | partition(Predicate<? super V> predicate)
Redeclares org. Filters a collection into a PartitionedIterable based on the evaluation of the predicate. |
| public <P> PartitionMutableBag | partitionWith(Predicate2<? super V, ? super P> predicate, P parameter)
Redeclares org. Filters a collection into a PartitionIterable based on the evaluation of the predicate. |
| public default <K> MutableMap | reduceBy(Function<? super V, ? extends K> groupBy, Function2<? super V, ? super V, ? extends V> reduceFunction)
Overrides default org. Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. |
| public MutableBag | reject(Predicate<? super V> predicate)
Redeclares org. Returns all elements of the source collection that return false when evaluating of the predicate. |
| public <P> MutableBag | rejectWith(Predicate2<? super V, ? super P> predicate, P parameter)
Redeclares org. Similar to |
| public MutableBag | select(Predicate<? super V> predicate)
Redeclares org. Returns all elements of the source collection that return true when evaluating the predicate. |
| public <S> MutableBag | selectInstancesOf(Class<S> clazz)
Redeclares org. Returns all elements of the source collection that are instances of the Class |
| public <P> MutableBag | selectWith(Predicate2<? super V, ? super P> predicate, P parameter)
Redeclares org. Similar to |
| public <VV> MutableObjectDoubleMap | sumByDouble(Function<? super V, ? extends VV> groupBy, DoubleFunction<? super V> function)
Redeclares org. Groups and sums the values using the two specified functions. |
| public <VV> MutableObjectDoubleMap | sumByFloat(Function<? super V, ? extends VV> groupBy, FloatFunction<? super V> function)
Redeclares org. Groups and sums the values using the two specified functions. |
| public <VV> MutableObjectLongMap | sumByInt(Function<? super V, ? extends VV> groupBy, IntFunction<? super V> function)
Redeclares org. Groups and sums the values using the two specified functions. |
| public <VV> MutableObjectLongMap | sumByLong(Function<? super V, ? extends VV> groupBy, LongFunction<? super V> function)
Redeclares org. Groups and sums the values using the two specified functions. |
| public <S> MutableBag | zip(Iterable<S> that)
Redeclares org.
Deprecated
in 7.0. Use
OrderedIterable#zip(Iterable) instead.
Returns a |
| public MutableSet | zipWithIndex()
Redeclares org.
Deprecated
in 7.0. Use
OrderedIterable#zipWithIndex() instead.
Zips this |
| aggregateBy | back to summary |
|---|---|
| public default <K, VV> MutableMap Overrides default org. Doc from org. Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. Aggregate results are allowed to be immutable as they will be replaced in place in the map. A second function specifies the initial "zero" aggregate value to work with (i.e. Integer.valueOf(0)).
| |
| aggregateInPlaceBy | back to summary |
|---|---|
| public <K, VV> MutableMap Redeclares as abstract: org. Doc from org. Applies an aggregate procedure over the iterable grouping results into a Map based on the specific groupBy function. Aggregate results are required to be mutable as they will be changed in place by the procedure. A second function specifies the initial "zero" aggregate value to work with (i.e. new AtomicInteger(0)).
| |
| clear | back to summary |
|---|---|
| public void clear() | |
| collect | back to summary |
|---|---|
| public <VV> MutableBag Redeclares org. Doc from org. Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map. Example using a Java 8 lambda expression:
RichIterable<String> names =
people.collect(person -> person.getFirstName() + " " + person.getLastName());
| |
| collectBoolean | back to summary |
|---|---|
| public MutableBooleanBag collectBoolean(BooleanFunction<? super V> booleanFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
BooleanIterable licenses =
people.collectBoolean(person -> person.hasDrivingLicense());
| |
| collectByte | back to summary |
|---|---|
| public MutableByteBag collectByte(ByteFunction<? super V> byteFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
ByteIterable bytes =
people.collectByte(person -> person.getCode());
| |
| collectChar | back to summary |
|---|---|
| public MutableCharBag collectChar(CharFunction<? super V> charFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
CharIterable chars =
people.collectChar(person -> person.getMiddleInitial());
| |
| collectDouble | back to summary |
|---|---|
| public MutableDoubleBag collectDouble(DoubleFunction<? super V> doubleFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
DoubleIterable doubles =
people.collectDouble(person -> person.getMilesFromNorthPole());
| |
| collectFloat | back to summary |
|---|---|
| public MutableFloatBag collectFloat(FloatFunction<? super V> floatFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
FloatIterable floats =
people.collectFloat(person -> person.getHeightInInches());
| |
| collectIf | back to summary |
|---|---|
| public <VV> MutableBag Redeclares org. Doc from org. Returns a new collection with the results of applying the specified function on each element of the source collection, but only for those elements which return true upon evaluation of the predicate. This is the optimized equivalent of calling iterable.select(predicate).collect(function). Example using a Java 8 lambda and method reference: RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(e -> e != null, Object::toString); Example using Predicates factory: RichIterable<String> strings = Lists.mutable.with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString());
| |
| collectInt | back to summary |
|---|---|
| public MutableIntBag collectInt(IntFunction<? super V> intFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
IntIterable ints =
people.collectInt(person -> person.getAge());
| |
| collectLong | back to summary |
|---|---|
| public MutableLongBag collectLong(LongFunction<? super V> longFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
LongIterable longs =
people.collectLong(person -> person.getGuid());
| |
| collectShort | back to summary |
|---|---|
| public MutableShortBag collectShort(ShortFunction<? super V> shortFunction) Redeclares org. Doc from org. Returns a new primitive Example using a Java 8 lambda expression:
ShortIterable shorts =
people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth());
| |
| collectWith | back to summary |
|---|---|
| public <P, VV> MutableBag Redeclares org. Doc from org. Same as Example using a Java 8 lambda expression:
RichIterable<Integer> integers =
Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1));
| |
| flatCollect | back to summary |
|---|---|
| public <VV> MutableBag Redeclares org. Doc from org.
Consider the following example where we have a Function<Person, List<Address>> addressFunction = Person::getAddresses; RichIterable<Person> people = ...;Using collect returns a collection of collections of addresses.
RichIterable<List<Address>> addresses = people.collect(addressFunction);Using flatCollect returns a single flattened list of addresses.
RichIterable<Address> addresses = people.flatCollect(addressFunction);
| |
| flatCollectWith | back to summary |
|---|---|
| public default <P, VV> MutableBag Overrides default org. Doc from org. Same as flatCollect, only with a Function2 that is passed an extra parameter.
| |
| groupBy | back to summary |
|---|---|
| public <VV> MutableBagMultimap Redeclares org. Doc from org. For each element of the iterable, the function is evaluated and the results of these evaluations are collected into a new multimap, where the transformed value is the key and the original values are added to the same (or similar) species of collection as the source iterable. Example using a Java 8 method reference:
Multimap<String, Person> peopleByLastName =
people.groupBy(Person::getLastName);
| |
| groupByEach | back to summary |
|---|---|
| public <VV> MutableBagMultimap Redeclares org. Doc from org. Similar to
| |
| groupByUniqueKey | back to summary |
|---|---|
| public default <VV> MutableMap Implements org. Doc from org. For each element of the iterable, the function is evaluated, and the results of these evaluations are collected into a new map, where the transformed value is the key. The generated keys must each be unique, or else an exception is thrown.
| |
| partition | back to summary |
|---|---|
| public PartitionMutableBag Redeclares org. Doc from org. Filters a collection into a PartitionedIterable based on the evaluation of the predicate. Example using a Java 8 lambda expression:
PartitionIterable<Person> newYorkersAndNonNewYorkers =
people.partition(person -> person.getAddress().getState().getName().equals("New York"));
| |
| partitionWith | back to summary |
|---|---|
| public <P> PartitionMutableBag Redeclares org. Doc from org. Filters a collection into a PartitionIterable based on the evaluation of the predicate. Example using a Java 8 lambda expression:
PartitionIterable<Person> newYorkersAndNonNewYorkers =
people.partitionWith((Person person, String state) -> person.getAddress().getState().getName().equals(state), "New York");
| |
| reduceBy | back to summary |
|---|---|
| public default <K> MutableMap Overrides default org. Doc from org. Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. Aggregate results are allowed to be immutable as they will be replaced in place in the map.
| |
| reject | back to summary |
|---|---|
| public MutableBag Redeclares org. Doc from org. Returns all elements of the source collection that return false when evaluating of the predicate. This method is also sometimes called filterNot and is the equivalent of calling iterable.select(Predicates.not(predicate)). Example using a Java 8 lambda expression:
RichIterable<Person> rejected =
people.reject(person -> person.person.getLastName().equals("Smith"));
| |
| rejectWith | back to summary |
|---|---|
| public <P> MutableBag Redeclares org. Doc from org. Similar to
E.g. return a Example using a Java 8 lambda expression:
RichIterable<Person> rejected =
people.rejectWith((Person person, Integer age) -> person.getAge() < age, Integer.valueOf(18));
| |
| select | back to summary |
|---|---|
| public MutableBag Redeclares org. Doc from org. Returns all elements of the source collection that return true when evaluating the predicate. This method is also commonly called filter. Example using a Java 8 lambda expression:
RichIterable<Person> selected =
people.select(person -> person.getAddress().getCity().equals("London"));
| |
| selectInstancesOf | back to summary |
|---|---|
| public <S> MutableBag Redeclares org. Doc from org. Returns all elements of the source collection that are instances of the Class
RichIterable<Integer> integers =
List.mutable.with(new Integer(0), new Long(0L), new Double(0.0)).selectInstancesOf(Integer.class);
| |
| selectWith | back to summary |
|---|---|
| public <P> MutableBag Redeclares org. Doc from org. Similar to
E.g. return a Example using a Java 8 lambda expression:
RichIterable<Person> selected =
people.selectWith((Person person, Integer age) -> person.getAge()>= age, Integer.valueOf(18));
| |
| sumByDouble | back to summary |
|---|---|
| public <VV> MutableObjectDoubleMap Redeclares org. Doc from org. Groups and sums the values using the two specified functions.
| |
| sumByFloat | back to summary |
|---|---|
| public <VV> MutableObjectDoubleMap Redeclares org. Doc from org. Groups and sums the values using the two specified functions.
| |
| sumByInt | back to summary |
|---|---|
| public <VV> MutableObjectLongMap Redeclares org. Doc from org. Groups and sums the values using the two specified functions.
| |
| sumByLong | back to summary |
|---|---|
| public <VV> MutableObjectLongMap Redeclares org. Doc from org. Groups and sums the values using the two specified functions.
| |
| zip | back to summary |
|---|---|
| public <S> MutableBag Redeclares org. Doc from org. Deprecated in 7.0. Use Returns a
| |
| zipWithIndex | back to summary |
|---|---|
| public MutableSet Redeclares org. Doc from org. Deprecated in 7.0. Use Zips this
| |