Class AbstractImmutableBag<T>

    • Constructor Detail

      • AbstractImmutableBag

        public AbstractImmutableBag()
    • Method Detail

      • selectWith

        public <P> ImmutableBag<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 ImmutableBag<T>
        Specified by:
        selectWith in interface ImmutableBagIterable<T>
        Specified by:
        selectWith in interface ImmutableCollection<T>
        Specified by:
        selectWith in interface RichIterable<T>
        Specified by:
        selectWith in interface UnsortedBag<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)
      • rejectWith

        public <P> ImmutableBag<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 ImmutableBag<T>
        Specified by:
        rejectWith in interface ImmutableBagIterable<T>
        Specified by:
        rejectWith in interface ImmutableCollection<T>
        Specified by:
        rejectWith in interface RichIterable<T>
        Specified by:
        rejectWith in interface UnsortedBag<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

        public PartitionImmutableBag<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 ImmutableBag<T>
        Specified by:
        partition in interface ImmutableBagIterable<T>
        Specified by:
        partition in interface ImmutableCollection<T>
        Specified by:
        partition in interface RichIterable<T>
        Specified by:
        partition in interface UnsortedBag<T>
      • partitionWith

        public <P> PartitionImmutableBag<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 ImmutableBag<T>
        Specified by:
        partitionWith in interface ImmutableBagIterable<T>
        Specified by:
        partitionWith in interface ImmutableCollection<T>
        Specified by:
        partitionWith in interface RichIterable<T>
      • collectWith

        public <P,​V> ImmutableBag<V> collectWith​(Function2<? super T,​? super P,​? extends V> function,
                                                       P parameter)
        Description copied from interface: RichIterable
        Same as RichIterable.collect(Function) with a Function2 and specified parameter which is passed to the block.

        Example using a Java 8 lambda expression:

         RichIterable<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith((each, parameter) -> each + parameter, Integer.valueOf(1));
         

        Example using an anonymous inner class:

         Function2<Integer, Integer, Integer> addParameterFunction =
             new Function2<Integer, Integer, Integer>()
             {
                 public Integer value(Integer each, Integer parameter)
                 {
                     return each + parameter;
                 }
             };
         RichIterable<Integer> integers =
             Lists.mutable.with(1, 2, 3).collectWith(addParameterFunction, Integer.valueOf(1));
         
        Specified by:
        collectWith in interface ImmutableBag<T>
        Specified by:
        collectWith in interface ImmutableCollection<T>
        Specified by:
        collectWith in interface RichIterable<T>
        Specified by:
        collectWith in interface UnsortedBag<T>
        Parameters:
        function - A Function2 to use as the collect transformation function
        parameter - A parameter to pass in for evaluation of the second argument P in function
        Returns:
        A new RichIterable that contains the transformed elements returned by Function2.value(Object, Object)
        See Also:
        RichIterable.collect(Function)
      • collectBoolean

        public ImmutableBooleanBag collectBoolean​(BooleanFunction<? super T> booleanFunction)
        Description copied from interface: RichIterable
        Returns a new primitive boolean iterable 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:

         BooleanIterable licenses =
             people.collectBoolean(person -> person.hasDrivingLicense());
         

        Example using an anonymous inner class:

         BooleanIterable licenses =
             people.collectBoolean(new BooleanFunction<Person>()
             {
                 public boolean booleanValueOf(Person person)
                 {
                     return person.hasDrivingLicense();
                 }
             });
         
        Specified by:
        collectBoolean in interface ImmutableBag<T>
        Specified by:
        collectBoolean in interface ImmutableCollection<T>
        Specified by:
        collectBoolean in interface RichIterable<T>
        Specified by:
        collectBoolean in interface UnsortedBag<T>
      • collectByte

        public ImmutableByteBag collectByte​(ByteFunction<? super T> byteFunction)
        Description copied from interface: RichIterable
        Returns a new primitive byte iterable 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:

         ByteIterable bytes =
             people.collectByte(person -> person.getCode());
         

        Example using an anonymous inner class:

         ByteIterable bytes =
             people.collectByte(new ByteFunction<Person>()
             {
                 public byte byteValueOf(Person person)
                 {
                     return person.getCode();
                 }
             });
         
        Specified by:
        collectByte in interface ImmutableBag<T>
        Specified by:
        collectByte in interface ImmutableCollection<T>
        Specified by:
        collectByte in interface RichIterable<T>
        Specified by:
        collectByte in interface UnsortedBag<T>
      • collectChar

        public ImmutableCharBag collectChar​(CharFunction<? super T> charFunction)
        Description copied from interface: RichIterable
        Returns a new primitive char iterable 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:

         CharIterable chars =
             people.collectChar(person -> person.getMiddleInitial());
         

        Example using an anonymous inner class:

         CharIterable chars =
             people.collectChar(new CharFunction<Person>()
             {
                 public char charValueOf(Person person)
                 {
                     return person.getMiddleInitial();
                 }
             });
         
        Specified by:
        collectChar in interface ImmutableBag<T>
        Specified by:
        collectChar in interface ImmutableCollection<T>
        Specified by:
        collectChar in interface RichIterable<T>
        Specified by:
        collectChar in interface UnsortedBag<T>
      • collectDouble

        public ImmutableDoubleBag collectDouble​(DoubleFunction<? super T> doubleFunction)
        Description copied from interface: RichIterable
        Returns a new primitive double iterable 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:

         DoubleIterable doubles =
             people.collectDouble(person -> person.getMilesFromNorthPole());
         

        Example using an anonymous inner class:

         DoubleIterable doubles =
             people.collectDouble(new DoubleFunction<Person>()
             {
                 public double doubleValueOf(Person person)
                 {
                     return person.getMilesFromNorthPole();
                 }
             });
         
        Specified by:
        collectDouble in interface ImmutableBag<T>
        Specified by:
        collectDouble in interface ImmutableCollection<T>
        Specified by:
        collectDouble in interface RichIterable<T>
        Specified by:
        collectDouble in interface UnsortedBag<T>
      • collectFloat

        public ImmutableFloatBag collectFloat​(FloatFunction<? super T> floatFunction)
        Description copied from interface: RichIterable
        Returns a new primitive float iterable 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:

         FloatIterable floats =
             people.collectFloat(person -> person.getHeightInInches());
         

        Example using an anonymous inner class:

         FloatIterable floats =
             people.collectFloat(new FloatFunction<Person>()
             {
                 public float floatValueOf(Person person)
                 {
                     return person.getHeightInInches();
                 }
             });
         
        Specified by:
        collectFloat in interface ImmutableBag<T>
        Specified by:
        collectFloat in interface ImmutableCollection<T>
        Specified by:
        collectFloat in interface RichIterable<T>
        Specified by:
        collectFloat in interface UnsortedBag<T>
      • collectInt

        public ImmutableIntBag collectInt​(IntFunction<? super T> intFunction)
        Description copied from interface: RichIterable
        Returns a new primitive int iterable 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:

         IntIterable ints =
             people.collectInt(person -> person.getAge());
         

        Example using an anonymous inner class:

         IntIterable ints =
             people.collectInt(new IntFunction<Person>()
             {
                 public int intValueOf(Person person)
                 {
                     return person.getAge();
                 }
             });
         
        Specified by:
        collectInt in interface ImmutableBag<T>
        Specified by:
        collectInt in interface ImmutableCollection<T>
        Specified by:
        collectInt in interface RichIterable<T>
        Specified by:
        collectInt in interface UnsortedBag<T>
      • collectLong

        public ImmutableLongBag collectLong​(LongFunction<? super T> longFunction)
        Description copied from interface: RichIterable
        Returns a new primitive long iterable 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:

         LongIterable longs =
             people.collectLong(person -> person.getGuid());
         

        Example using an anonymous inner class:

         LongIterable longs =
             people.collectLong(new LongFunction<Person>()
             {
                 public long longValueOf(Person person)
                 {
                     return person.getGuid();
                 }
             });
         
        Specified by:
        collectLong in interface ImmutableBag<T>
        Specified by:
        collectLong in interface ImmutableCollection<T>
        Specified by:
        collectLong in interface RichIterable<T>
        Specified by:
        collectLong in interface UnsortedBag<T>
      • collectShort

        public ImmutableShortBag collectShort​(ShortFunction<? super T> shortFunction)
        Description copied from interface: RichIterable
        Returns a new primitive short iterable 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:

         ShortIterable shorts =
             people.collectShort(person -> person.getNumberOfJunkMailItemsReceivedPerMonth());
         

        Example using an anonymous inner class:

         ShortIterable shorts =
             people.collectShort(new ShortFunction<Person>()
             {
                 public short shortValueOf(Person person)
                 {
                     return person.getNumberOfJunkMailItemsReceivedPerMonth();
                 }
             });
         
        Specified by:
        collectShort in interface ImmutableBag<T>
        Specified by:
        collectShort in interface ImmutableCollection<T>
        Specified by:
        collectShort in interface RichIterable<T>
        Specified by:
        collectShort in interface UnsortedBag<T>
      • topOccurrences

        public ImmutableList<ObjectIntPair<T>> topOccurrences​(int n)
        Description copied from interface: Bag
        Returns the count most frequently occurring items. In the event of a tie, all the items with the number of occurrences that match the occurrences of the last item will be returned.
        Specified by:
        topOccurrences in interface Bag<T>
        Specified by:
        topOccurrences in interface ImmutableBag<T>
      • bottomOccurrences

        public ImmutableList<ObjectIntPair<T>> bottomOccurrences​(int n)
        Description copied from interface: Bag
        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.
        Specified by:
        bottomOccurrences in interface Bag<T>
        Specified by:
        bottomOccurrences in interface ImmutableBag<T>
      • chunk

        public RichIterable<RichIterable<T>> chunk​(int size)
        Description copied from interface: RichIterable
        Partitions elements in fixed size chunks.
        Specified by:
        chunk in interface RichIterable<T>
        Parameters:
        size - the number of elements per chunk
        Returns:
        A RichIterable containing RichIterables of size size, except the last will be truncated if the elements don't divide evenly.