Bag (Eclipse Collections

All Superinterfaces:

InternalIterable<T>, Iterable<T>, RichIterable<T>

All Known Subinterfaces:

ImmutableBag<T>, ImmutableBagIterable<T>, ImmutableSortedBag<T>, MutableBag<T>, MutableBagIterable<T>, MutableSortedBag<T>, SortedBag<T>, UnsortedBag<T>

All Known Implementing Classes:

AbstractBag, AbstractImmutableBag, AbstractImmutableBagIterable, AbstractMutableBag, AbstractMutableBagIterable, AbstractMutableSortedBag, HashBag, ImmutableArrayBag, ImmutableHashBag, MultiReaderHashBag, SynchronizedBag, SynchronizedSortedBag, TreeBag, UnmodifiableBag, UnmodifiableSortedBag
```
public interface Bag<T>
extends RichIterable<T>
```
A Bag is a Collection whose elements are unordered and may contain duplicate entries. It varies from MutableCollection in that it adds a protocol for determining, adding, and removing the number of occurrences for an item.

Since:

1.0

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`ListIterable<ObjectIntPair<T>>`	`bottomOccurrences(int count)` Returns the `count` least frequently occurring items.
`boolean`	`equals(Object object)` Two bags`b1` and `b2` are equal if `m1.toMapOfItemToCount().equals(m2.toMapOfItemToCount())`.
`void`	`forEachWithOccurrences(ObjectIntProcedure<? super T> procedure)` For each distinct item, with the number of occurrences, execute the specified procedure.
`<V> BagMultimap<V,T>`	`groupBy(Function<? super T,? extends V> function)` 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.
`<V> BagMultimap<V,T>`	`groupByEach(Function<? super T,? extends Iterable<V>> function)` Similar to `RichIterable.groupBy(Function)`, except the result of evaluating function will return a collection of keys for each value.
`int`	`hashCode()` Returns the hash code for this Bag, defined as `this.toMapOfItemToCount().hashCode()`.
`int`	`occurrencesOf(Object item)` The occurrences of a distinct item in the bag.
`PartitionBag<T>`	`partition(Predicate<? super T> predicate)` Filters a collection into a PartitionedIterable based on the evaluation of the predicate.
`<P> PartitionBag<T>`	`partitionWith(Predicate2<? super T,? super P> predicate, P parameter)` Filters a collection into a PartitionIterable based on the evaluation of the predicate.
`Bag<T>`	`reject(Predicate<? super T> predicate)` Returns all elements of the source collection that return false when evaluating of the predicate.
`<P> Bag<T>`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter)` Similar to `RichIterable.reject(Predicate)`, except with an evaluation parameter for the second generic argument in `Predicate2`.
`Bag<T>`	`select(Predicate<? super T> predicate)` Returns all elements of the source collection that return true when evaluating the predicate.
`Bag<T>`	`selectByOccurrences(IntPredicate predicate)` Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
`<S> Bag<S>`	`selectInstancesOf(Class<S> clazz)` Returns all elements of the source collection that are instances of the Class `clazz`.
`<P> Bag<T>`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter)` Similar to `RichIterable.select(Predicate)`, except with an evaluation parameter for the second generic argument in `Predicate2`.
`int`	`sizeDistinct()` The size of the Bag when counting only distinct elements.
`Bag<T>`	`tap(Procedure<? super T> procedure)` Executes the Procedure for each element in the iterable and returns `this`.
`ImmutableBagIterable<T>`	`toImmutable()`
`MapIterable<T,Integer>`	`toMapOfItemToCount()` Converts the Bag to a Map of the Item type to its count as an Integer.
`ListIterable<ObjectIntPair<T>>`	`topOccurrences(int count)` Returns the `count` most frequently occurring items.
`String`	`toStringOfItemToCount()` Returns a string representation of this bag.
`SetIterable<Pair<T,Integer>>`	`zipWithIndex()` Zips this `RichIterable` with its indices.

Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, aggregateInPlaceBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collect, collectBoolean, collectBoolean, collectByte, collectByte, collectChar, collectChar, collectDouble, collectDouble, collectFloat, collectFloat, collectIf, collectIf, collectInt, collectInt, collectLong, collectLong, collectShort, collectShort, collectWith, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, each, flatCollect, flatCollect, getFirst, getLast, groupBy, groupByEach, groupByUniqueKey, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, size, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach, forEachWith, forEachWithIndex

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

- Method Detail
  - equals
```
boolean equals(Object object)
```
    Two bagsb1 and b2 are equal if m1.toMapOfItemToCount().equals(m2.toMapOfItemToCount()).
    
    Overrides:
    
    equals in class Object
    
    See Also:
    
    Map.equals(Object)
  - hashCode
```
int hashCode()
```
    Returns the hash code for this Bag, defined as this.toMapOfItemToCount().hashCode().
    
    Overrides:
    
    hashCode in class Object
    
    See Also:
    
    Map.hashCode()
  - tap
```
Bag<T> tap(Procedure<? super T> procedure)
```
    Description copied from interface: RichIterable
    Executes the Procedure for each element in the iterable and returns this.
    Example using a Java 8 lambda expression:
```
 RichIterable<Person> tapped =
     people.tap(person -> LOGGER.info(person.getName()));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> tapped =
     people.tap(new Procedure()
     {
         public void value(Person person)
         {
             LOGGER.info(person.getName());
         }
     });
 
```
    Specified by:
    
    tap in interface RichIterable<T>
    
    See Also:
    
    RichIterable.each(Procedure), InternalIterable.forEach(Procedure)
  - select
```
Bag<T> select(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    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"));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> selected =
     people.select(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.getAddress().getCity().equals("London");
         }
     });
```
    Specified by:
    
    select in interface RichIterable<T>
  - selectWith
```
<P> Bag<T> selectWith(Predicate2<? super T,? super P> predicate,
                      P parameter)
```
    Description copied from interface: RichIterable
    Similar to RichIterable.select(Predicate), 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:
```
 RichIterable<Person> selected =
     people.selectWith((Person person, Integer age) -> person.getAge() >= age, Integer.valueOf(18));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> selected =
     people.selectWith(new Predicate2<Person, Integer>()
     {
         public boolean accept(Person person, Integer age)
         {
             return person.getAge() >= age;
         }
     }, Integer.valueOf(18));
 
```
    Specified by:
    
    selectWith in interface RichIterable<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
    
    See Also:
    
    RichIterable.select(Predicate)
  - reject
```
Bag<T> reject(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    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"));
 
```
    Example using an anonymous inner class:
```
 RichIterable<Person> rejected =
     people.reject(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.person.getLastName().equals("Smith");
         }
     });
 
```
    Specified by:
    
    reject in interface RichIterable<T>
    
    Parameters:
    
    predicate - a Predicate to use as the reject criteria
    
    Returns:
    
    a RichIterable that contains elements that cause Predicate.accept(Object) method to evaluate to false
  - rejectWith
```
<P> Bag<T> rejectWith(Predicate2<? super T,? super P> predicate,
                      P parameter)
```
    Description copied from interface: RichIterable
    Similar to RichIterable.reject(Predicate), 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:
```
 RichIterable<Person> rejected =
     people.rejectWith((Person person, Integer age) -> person.getAge() < age, Integer.valueOf(18));
 
```
    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));
 
```
    Specified by:
    
    rejectWith in interface RichIterable<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
    
    See Also:
    
    RichIterable.select(Predicate)
  - partition
```
PartitionBag<T> partition(Predicate<? super T> predicate)
```
    Description copied from interface: RichIterable
    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"));
 
```
    Example using an anonymous inner class:
```
 PartitionIterable<Person> newYorkersAndNonNewYorkers =
     people.partition(new Predicate<Person>()
     {
         public boolean accept(Person person)
         {
             return person.getAddress().getState().getName().equals("New York");
         }
     });
 
```
    Specified by:
    
    partition in interface RichIterable<T>
  - partitionWith
```
<P> PartitionBag<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                  P parameter)
```
    Description copied from interface: RichIterable
    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");
 
```
    Example using an anonymous inner class:
```
 PartitionIterable<Person>> newYorkersAndNonNewYorkers =
     people.partitionWith(new Predicate2<Person, String>()
     {
         public boolean accept(Person person, String state)
         {
             return person.getAddress().getState().getName().equals(state);
         }
     }, "New York");
 
```
    Specified by:
    
    partitionWith in interface RichIterable<T>
  - selectInstancesOf
```
<S> Bag<S> selectInstancesOf(Class<S> clazz)
```
    Description copied from interface: RichIterable
    
    Returns all elements of the source collection that are instances of the Class clazz.
    
    Specified by:
    
    selectInstancesOf in interface RichIterable<T>
  - groupBy
```
<V> BagMultimap<V,T> groupBy(Function<? super T,? extends V> function)
```
    Description copied from interface: RichIterable
    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);
 
```
    Example using an anonymous inner class:
```
 Multimap<String, Person> peopleByLastName =
     people.groupBy(new Function<Person, String>()
     {
         public String value(Person person)
         {
             return person.getLastName();
         }
     });
 
```
    Specified by:
    
    groupBy in interface RichIterable<T>
  - groupByEach
```
<V> BagMultimap<V,T> groupByEach(Function<? super T,? extends Iterable<V>> function)
```
    Description copied from interface: RichIterable
    
    Similar to RichIterable.groupBy(Function), except the result of evaluating function will return a collection of keys for each value.
    
    Specified by:
    
    groupByEach in interface RichIterable<T>
  - zipWithIndex
```
SetIterable<Pair<T,Integer>> zipWithIndex()
```
    Description copied from interface: RichIterable
    
    Zips this RichIterable with its indices.
    
    Specified by:
    
    zipWithIndex in interface RichIterable<T>
    
    Returns:
    
    A new RichIterable containing pairs consisting of all elements of this RichIterable paired with their index. Indices start at 0.
    
    See Also:
    
    RichIterable.zip(Iterable)
  - forEachWithOccurrences
```
void forEachWithOccurrences(ObjectIntProcedure<? super T> procedure)
```
    For each distinct item, with the number of occurrences, execute the specified procedure.
  - occurrencesOf
```
int occurrencesOf(Object item)
```
    The occurrences of a distinct item in the bag.
  - selectByOccurrences
```
Bag<T> selectByOccurrences(IntPredicate predicate)
```
    Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
    
    Since:
    
    3.0
  - topOccurrences
```
ListIterable<ObjectIntPair<T>> topOccurrences(int count)
```
    Returns the count most frequently occurring items. In the event of a tie, all of the items with the number of occurrences that match the occurrences of the last item will be returned.
    
    Since:
    
    6.0
  - bottomOccurrences
```
ListIterable<ObjectIntPair<T>> bottomOccurrences(int count)
```
    Returns the count least frequently occurring items. In the event of a tie, all of the items with the number of occurrences that match the occurrences of the last item will be returned.
    
    Since:
    
    6.0
  - sizeDistinct
```
int sizeDistinct()
```
    The size of the Bag when counting only distinct elements.
  - toMapOfItemToCount
```
MapIterable<T,Integer> toMapOfItemToCount()
```
    Converts the Bag to a Map of the Item type to its count as an Integer.
  - toStringOfItemToCount
```
String toStringOfItemToCount()
```
    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 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().
    
    Returns:
    
    a string representation of this bag
    
    Since:
    
    3.0
  - toImmutable
```
ImmutableBagIterable<T> toImmutable()
```

Interface Bag<T>

Method Summary

Methods inherited from interface org.eclipse.collections.api.RichIterable

Methods inherited from interface org.eclipse.collections.api.InternalIterable

Methods inherited from interface java.lang.Iterable

Method Detail

equals

hashCode

tap

select

selectWith

reject

rejectWith

partition

partitionWith

selectInstancesOf

groupBy

groupByEach

zipWithIndex

forEachWithOccurrences

occurrencesOf

selectByOccurrences

topOccurrences

bottomOccurrences

sizeDistinct

toMapOfItemToCount

toStringOfItemToCount

toImmutable