Package org.eclipse.collections.api.bag

Interface ImmutableBagIterable<T>

All Superinterfaces:
Bag<T>, ImmutableCollection<T>, InternalIterable<T>, Iterable<T>, RichIterable<T>
All Known Subinterfaces:
ImmutableBag<T>, ImmutableSortedBag<T>
All Known Implementing Classes:
AbstractImmutableBag, AbstractImmutableBagIterable, ImmutableArrayBag, ImmutableHashBag
public interface ImmutableBagIterable<T>
extends Bag<T>, ImmutableCollection<T>

  • Method Details

    • tap

      ImmutableBagIterable<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<Person>()
     {
         public void value(Person person)
         {
             LOGGER.info(person.getName());
         }
     });
      Specified by:
      tap in interface Bag<T>
      Specified by:
      tap in interface ImmutableCollection<T>
      Specified by:
      tap in interface RichIterable<T>
      See Also:
      RichIterable.each(Procedure), RichIterable.forEach(Procedure)

    • select

      ImmutableBagIterable<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 Bag<T>
      Specified by:
      select in interface ImmutableCollection<T>
      Specified by:
      select in interface RichIterable<T>

    • selectWith

      <P> ImmutableBagIterable<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 Bag<T>
      Specified by:
      selectWith in interface ImmutableCollection<T>
      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

      ImmutableBagIterable<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 Bag<T>
      Specified by:
      reject in interface ImmutableCollection<T>
      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> ImmutableBagIterable<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 Bag<T>
      Specified by:
      rejectWith in interface ImmutableCollection<T>
      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

      PartitionImmutableBagIterable<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 Bag<T>
      Specified by:
      partition in interface ImmutableCollection<T>
      Specified by:
      partition in interface RichIterable<T>

    • partitionWith

      <P> PartitionImmutableBagIterable<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 Bag<T>
      Specified by:
      partitionWith in interface ImmutableCollection<T>
      Specified by:
      partitionWith in interface RichIterable<T>

    • selectInstancesOf

      <S> ImmutableBagIterable<S> selectInstancesOf​(Class<S> clazz)
      Description copied from interface: RichIterable
      Returns all elements of the source collection that are instances of the Class clazz. 
       RichIterable<Integer> integers =
     List.mutable.with(new Integer(0), new Long(0L), new Double(0.0)).selectInstancesOf(Integer.class);
      Specified by:
      selectInstancesOf in interface Bag<T>
      Specified by:
      selectInstancesOf in interface ImmutableCollection<T>
      Specified by:
      selectInstancesOf in interface RichIterable<T>

    • groupBy

      <V> ImmutableBagIterableMultimap<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 valueOf(Person person)
         {
             return person.getLastName();
         }
     });
      Specified by:
      groupBy in interface Bag<T>
      Specified by:
      groupBy in interface ImmutableCollection<T>
      Specified by:
      groupBy in interface RichIterable<T>

    • groupByEach

      <V> ImmutableBagIterableMultimap<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 Bag<T>
      Specified by:
      groupByEach in interface ImmutableCollection<T>
      Specified by:
      groupByEach in interface RichIterable<T>

    • zipWithIndex

      ImmutableSetIterable<Pair<T,​Integer>> zipWithIndex()
      Description copied from interface: RichIterable
      Zips this RichIterable with its indices.
      Specified by:
      zipWithIndex in interface Bag<T>
      Specified by:
      zipWithIndex in interface ImmutableCollection<T>
      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)

    • selectByOccurrences

      ImmutableBagIterable<T> selectByOccurrences​(IntPredicate predicate)
      Description copied from interface: Bag
      Returns all elements of the bag that have a number of occurrences that satisfy the predicate.
      Specified by:
      selectByOccurrences in interface Bag<T>

    • selectDuplicates

      default ImmutableBagIterable<T> selectDuplicates()
      Description copied from interface: Bag
      Returns all elements of the bag that have more than one occurrence.
      Specified by:
      selectDuplicates in interface Bag<T>
      Since:
      9.2

    • selectUnique

      ImmutableSetIterable<T> selectUnique()
      Description copied from interface: Bag
      Returns a set containing all elements of the bag that have exactly one occurrence.
      Specified by:
      selectUnique in interface Bag<T>
      Since:
      9.2

    • toMapOfItemToCount

      MutableMapIterable<T,​Integer> toMapOfItemToCount()
      Description copied from interface: Bag
      Converts the Bag to a Map of the Item type to its count as an Integer.
      Specified by:
      toMapOfItemToCount in interface Bag<T>

    • collectWithOccurrences

      <V> ImmutableCollection<V> collectWithOccurrences​(ObjectIntToObjectFunction<? super T,​? extends V> function)
      Description copied from interface: Bag
      Iterates over the unique elements and their occurrences and collects the results of applying the specified function.
      Specified by:
      collectWithOccurrences in interface Bag<T>