| Modifier and Type | Method and Description |
|---|---|
| public default <K, V, R extends MutableMapIterable | aggregateBy(Function<? super T, ? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V, ? super T, ? extends V> nonMutatingAggregator, R target)
Overrides default org. Applies an aggregate function over the iterable grouping results into the target map based on the specific groupBy function. |
| public boolean | allSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
Returns true if the predicate evaluates to true for all elements of the Bag. |
| public boolean | anySatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
Returns true if the predicate evaluates to true for any element of the Bag. |
| public ListIterable | |
| public <V> RichIterable | collectWithOccurrences(ObjectIntToObjectFunction<? super T, ? extends V> function)
Iterates over the unique elements and their occurrences and collects the results of applying the specified function. |
| public default <V, R extends Collection | collectWithOccurrences(ObjectIntToObjectFunction<? super T, ? extends V> function, R target)
Iterates over the unique elements and their occurrences and collects the results of applying the specified function into the target collection. |
| public T | detectWithOccurrences(ObjectIntPredicate<? super T> predicate)
Returns an element of the Bag that satisfies the predicate or null if such an element does not exist |
| public default RichIterable | Returns: an unmodifiable view on the distinct elements of the Bag.Returns an unmodifiable view on the distinct elements with the same complexity as the Bag implementation. |
| public boolean | |
| public void | forEachWithOccurrences(ObjectIntProcedure<? super T> procedure)
For each distinct item, with the number of occurrences, execute the specified procedure. |
| public <V> BagMultimap | groupBy(Function<? super T, ? extends V> 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 <V> BagMultimap | groupByEach(Function<? super T, ? extends Iterable<V>> function)
Redeclares org. Similar to |
| public int | |
| public boolean | noneSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate)
Returns true if the Bag is empty or if the predicate evaluates to false for all elements of the Bag. |
| public int | |
| public PartitionBag | partition(Predicate<? super T> predicate)
Redeclares org. Filters a collection into a PartitionedIterable based on the evaluation of the predicate. |
| public <P> PartitionBag | partitionWith(Predicate2<? super T, ? super P> predicate, P parameter)
Redeclares org. Filters a collection into a PartitionIterable based on the evaluation of the predicate. |
| public default <K, R extends MutableMapIterable | reduceBy(Function<? super T, ? extends K> groupBy, Function2<? super T, ? super T, ? extends T> reduceFunction, R target)
Overrides default org. Applies an aggregate function over the iterable grouping results into a map based on the specific groupBy function. |
| public default <R, A> R | reduceInPlace(Collector<? super T, A, R> collector)
Overrides default org. This method produces the equivalent result as |
| public default <R> R | reduceInPlace(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator)
Overrides default org. This method produces the equivalent result as |
| public Bag | reject(Predicate<? super T> predicate)
Redeclares org. Returns all elements of the source collection that return false when evaluating of the predicate. |
| public <P> Bag | rejectWith(Predicate2<? super T, ? super P> predicate, P parameter)
Redeclares org. Similar to |
| public Bag | select(Predicate<? super T> predicate)
Redeclares org. Returns all elements of the source collection that return true when evaluating the predicate. |
| public Bag | selectByOccurrences(IntPredicate predicate)
Returns all elements of the bag that have a number of occurrences that satisfy the predicate. |
| public default Bag | |
| public <S> Bag | selectInstancesOf(Class<S> clazz)
Redeclares org. Returns all elements of the source collection that are instances of the Class |
| public SetIterable | |
| public <P> Bag | selectWith(Predicate2<? super T, ? super P> predicate, P parameter)
Redeclares org. Similar to |
| public int | |
| public default DoubleSummaryStatistics | summarizeDouble(DoubleFunction<? super T> function)
Overrides default org. Returns the result of summarizing the value returned from applying the DoubleFunction to each element of the iterable. |
| public default DoubleSummaryStatistics | summarizeFloat(FloatFunction<? super T> function)
Overrides default org. Returns the result of summarizing the value returned from applying the FloatFunction to each element of the iterable. |
| public default IntSummaryStatistics | summarizeInt(IntFunction<? super T> function)
Overrides default org. Returns the result of summarizing the value returned from applying the IntFunction to each element of the iterable. |
| public default LongSummaryStatistics | summarizeLong(LongFunction<? super T> function)
Overrides default org. Returns the result of summarizing the value returned from applying the LongFunction to each element of the iterable. |
| public Bag | tap(Procedure<? super T> procedure)
Redeclares org. Executes the Procedure for each element in the iterable and returns |
| public ImmutableBagIterable | |
| public MapIterable | |
| public ListIterable | |
| public String | Returns: a string representation of this bagReturns a string representation of this bag. |
| public SetIterable | zipWithIndex()
Redeclares org. Zips this |
| aggregateBy | back to summary |
|---|---|
| public default <K, V, R extends MutableMapIterable Overrides default org. Applies an aggregate function over the iterable grouping results into the target 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)). This method is overridden and optimized for Bag to use forEachWithOccurrences instead of forEach.
| |
| allSatisfyWithOccurrences | back to summary |
|---|---|
| public boolean allSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate) Returns true if the predicate evaluates to true for all elements of the Bag. Returns false if the Bag is empty or if not all elements return true for the predicate.
| |
| anySatisfyWithOccurrences | back to summary |
|---|---|
| public boolean anySatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate) Returns true if the predicate evaluates to true for any element of the Bag. Returns false if the Bag is empty or if no element returns true for the predicate.
| |
| bottomOccurrences | back to summary |
|---|---|
| public ListIterable Returns the
| |
| collectWithOccurrences | back to summary |
|---|---|
| public <V> RichIterable Iterates over the unique elements and their occurrences and collects the results of applying the specified function.
| |
| collectWithOccurrences | back to summary |
|---|---|
| public default <V, R extends Collection Iterates over the unique elements and their occurrences and collects the results of applying the specified function into the target collection.
| |
| detectWithOccurrences | back to summary |
|---|---|
| public T detectWithOccurrences(ObjectIntPredicate<? super T> predicate) Returns an element of the Bag that satisfies the predicate or null if such an element does not exist
| |
| distinctView | back to summary |
|---|---|
| public default RichIterable Returns an unmodifiable view on the distinct elements with the same complexity as the Bag implementation.
| |
| equals | back to summary |
|---|---|
| public boolean equals(Object object) Two bags
| |
| forEachWithOccurrences | back to summary |
|---|---|
| public void forEachWithOccurrences(ObjectIntProcedure<? super T> procedure) For each distinct item, with the number of occurrences, execute the specified procedure. | |
| groupBy | back to summary |
|---|---|
| public <V> BagMultimap 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 <V> BagMultimap Redeclares org. Doc from org. Similar to
| |
| hashCode | back to summary |
|---|---|
| public int hashCode() Returns the hash code for this Bag, defined as this.
| |
| noneSatisfyWithOccurrences | back to summary |
|---|---|
| public boolean noneSatisfyWithOccurrences(ObjectIntPredicate<? super T> predicate) Returns true if the Bag is empty or if the predicate evaluates to false for all elements of the Bag. Returns false if the predicate evaluates to true for at least one element of the Bag.
| |
| occurrencesOf | back to summary |
|---|---|
| public int occurrencesOf(Object item) The occurrences of a distinct item in the bag. | |
| partition | back to summary |
|---|---|
| public PartitionBag 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> PartitionBag 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, R extends MutableMapIterable 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.
| |
| reduceInPlace | back to summary |
|---|---|
| public default <R, A> R reduceInPlace(Collector<? super T, A, R> collector) Overrides default org. This method produces the equivalent result as
| |
| reduceInPlace | back to summary |
|---|---|
| public default <R> R reduceInPlace(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator) Overrides default org. This method produces the equivalent result as
| |
| reject | back to summary |
|---|---|
| public Bag 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> Bag 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 Bag 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"));
| |
| selectByOccurrences | back to summary |
|---|---|
| public Bag Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
| |
| selectDuplicates | back to summary |
|---|---|
| public default Bag Returns all elements of the bag that have more than one occurrence.
| |
| selectInstancesOf | back to summary |
|---|---|
| public <S> Bag 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);
| |
| selectUnique | back to summary |
|---|---|
| public SetIterable Returns a set containing all elements of the bag that have exactly one occurrence.
| |
| selectWith | back to summary |
|---|---|
| public <P> Bag 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));
| |
| sizeDistinct | back to summary |
|---|---|
| public int sizeDistinct() The size of the Bag when counting only distinct elements. | |
| summarizeDouble | back to summary |
|---|---|
| public default DoubleSummaryStatistics summarizeDouble(DoubleFunction<? super T> function) Overrides default org. Doc from org. Returns the result of summarizing the value returned from applying the DoubleFunction to each element of the iterable.
DoubleSummaryStatistics stats =
Lists.mutable.with(1, 2, 3).summarizeDouble(Integer::doubleValue);
| |
| summarizeFloat | back to summary |
|---|---|
| public default DoubleSummaryStatistics summarizeFloat(FloatFunction<? super T> function) Overrides default org. Doc from org. Returns the result of summarizing the value returned from applying the FloatFunction to each element of the iterable.
DoubleSummaryStatistics stats =
Lists.mutable.with(1, 2, 3).summarizeFloat(Integer::floatValue);
| |
| summarizeInt | back to summary |
|---|---|
| public default IntSummaryStatistics summarizeInt(IntFunction<? super T> function) Overrides default org. Doc from org. Returns the result of summarizing the value returned from applying the IntFunction to each element of the iterable.
IntSummaryStatistics stats =
Lists.mutable.with(1, 2, 3).summarizeInt(Integer::intValue);
| |
| summarizeLong | back to summary |
|---|---|
| public default LongSummaryStatistics summarizeLong(LongFunction<? super T> function) Overrides default org. Doc from org. Returns the result of summarizing the value returned from applying the LongFunction to each element of the iterable.
LongSummaryStatistics stats =
Lists.mutable.with(1, 2, 3).summarizeLong(Integer::longValue);
| |
| tap | back to summary |
|---|---|
| public Bag Redeclares org. Doc from org. Executes the Procedure for each element in the iterable and returns Example using a Java 8 lambda expression:
RichIterable<Person> tapped =
people.tap(person -> LOGGER.info(person.getName()));
| |
| toImmutable | back to summary |
|---|---|
| public ImmutableBagIterable | |
| toMapOfItemToCount | back to summary |
|---|---|
| public MapIterable Converts the Bag to a Map of the Item type to its count as an Integer. | |
| topOccurrences | back to summary |
|---|---|
| public ListIterable Returns the
| |
| toStringOfItemToCount | back to summary |
|---|---|
| public String toStringOfItemToCount() Returns a string representation of this bag. The string representation consists of a list of element-count mappings.
Assert.assertEquals("{1=1, 2=2, 3=3}", Bags.mutable.with(1, 2, 2, 3, 3, 3).toStringOfItemToCount());
This string representation is similar to java., not RichIterable#toString(),
whereas the toString() implementation for a Bag is consistent with RichIterable#toString().
| |
| zipWithIndex | back to summary |
|---|---|
| public SetIterable Redeclares org. Doc from org. Zips this
| |