Iterable<T>
, Collection<T>
, Bag<T>
, ImmutableBag<T>
, ImmutableBagIterable<T>
, UnsortedBag<T>
, ImmutableCollection<T>
, InternalIterable<T>
, RichIterable<T>
ImmutableArrayBag
, ImmutableHashBag
public abstract class AbstractImmutableBag<T> extends AbstractImmutableBagIterable<T> implements ImmutableBag<T>
Constructor | Description |
---|---|
AbstractImmutableBag() |
Modifier and Type | Method | Description |
---|---|---|
ImmutableList<ObjectIntPair<T>> |
bottomOccurrences(int n) |
Returns the
count least frequently occurring items. |
RichIterable<RichIterable<T>> |
chunk(int size) |
Partitions elements in fixed size chunks.
|
ImmutableBooleanBag |
collectBoolean(BooleanFunction<? super T> booleanFunction) |
Returns a new primitive
boolean iterable with the results of applying the specified function on each element
of the source collection. |
ImmutableByteBag |
collectByte(ByteFunction<? super T> byteFunction) |
Returns a new primitive
byte iterable with the results of applying the specified function on each element
of the source collection. |
ImmutableCharBag |
collectChar(CharFunction<? super T> charFunction) |
Returns a new primitive
char iterable with the results of applying the specified function on each element
of the source collection. |
ImmutableDoubleBag |
collectDouble(DoubleFunction<? super T> doubleFunction) |
Returns a new primitive
double iterable with the results of applying the specified function on each element
of the source collection. |
ImmutableFloatBag |
collectFloat(FloatFunction<? super T> floatFunction) |
Returns a new primitive
float iterable with the results of applying the specified function on each element
of the source collection. |
ImmutableIntBag |
collectInt(IntFunction<? super T> intFunction) |
Returns a new primitive
int iterable with the results of applying the specified function on each element
of the source collection. |
ImmutableLongBag |
collectLong(LongFunction<? super T> longFunction) |
Returns a new primitive
long iterable with the results of applying the specified function on each element
of the source collection. |
ImmutableShortBag |
collectShort(ShortFunction<? super T> shortFunction) |
Returns a new primitive
short iterable with the results of applying the specified function on each element
of the source collection. |
<P,V> ImmutableBag<V> |
collectWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
Same as
RichIterable.collect(Function) with a Function2 and specified parameter which is passed to the block. |
<V> ImmutableBag<V> |
collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function) |
Iterates over the unique elements and their occurrences and collects the results of applying the specified function.
|
<V> ImmutableBag<V> |
countBy(Function<? super T,? extends V> function) |
This method will count the number of occurrences of each value calculated by applying the
function to each element of the collection.
|
<V> ImmutableBag<V> |
countByEach(Function<? super T,? extends Iterable<V>> function) |
This method will count the number of occurrences of each value calculated by applying the
function to each element of the collection.
|
<V,P> ImmutableBag<V> |
countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
This method will count the number of occurrences of each value calculated by applying the
function to each element of the collection with the specified parameter as the second argument.
|
<V> ImmutableMap<V,T> |
groupByUniqueKey(Function<? super T,? extends V> function) |
For each element of the iterable, the function is evaluated and he results of these evaluations are collected
into a new map, where the transformed value is the key.
|
ImmutableBag<T> |
newWithoutAll(Iterable<? extends T> elements) |
This method is similar to the
withoutAll method in MutableCollection
with the difference that a new copy of this collection with the elements removed will be returned. |
PartitionImmutableBag<T> |
partition(Predicate<? super T> predicate) |
Filters a collection into a PartitionedIterable based on the evaluation of the predicate.
|
<P> PartitionImmutableBag<T> |
partitionWith(Predicate2<? super T,? super P> predicate,
P parameter) |
Filters a collection into a PartitionIterable based on the evaluation of the predicate.
|
<P> ImmutableBag<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 . |
<P> ImmutableBag<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 . |
ImmutableBag<T> |
tap(Procedure<? super T> procedure) |
Executes the Procedure for each element in the iterable and returns
this . |
ImmutableBag<T> |
toImmutable() |
|
ImmutableList<ObjectIntPair<T>> |
topOccurrences(int n) |
Returns the
count most frequently occurring items. |
collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, count, flatCollect, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoWith, reject, rejectWith, select, selectWith, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toList, toSet, toSortedBag, toSortedBag, toSortedList, toSortedSet, toSortedSet, toStringOfItemToCount
add, addAll, aggregateBy, aggregateInPlaceBy, castToCollection, clear, parallelStream, remove, removeAll, retainAll, spliterator, stream, sumByDouble, sumByFloat, sumByInt, sumByLong
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, asLazy, contains, containsAll, containsAllArguments, containsAllIterable, countWith, detect, detectOptional, detectWith, detectWithIfNone, detectWithOptional, forEach, forEachWith, forEachWithIndex, groupByUniqueKey, into, isEmpty, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, toArray, toArray, toBiMap, toMap, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSetBy, toString, zip, zipWithIndex
collectWithOccurrences, equals, forEachWithOccurrences, hashCode, occurrencesOf, reduceInPlace, reduceInPlace, sizeDistinct, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, toStringOfItemToCount
contains, containsAll, equals, hashCode, isEmpty, iterator, removeIf, size, toArray, toArray
collect, collectIf, flatCollect, flatCollectWith, groupBy, groupByEach, newWith, newWithAll, newWithout, reject, select, selectByOccurrences, selectDuplicates, selectInstancesOf, selectUnique, zip, zipWithIndex
toMapOfItemToCount
aggregateBy, aggregateInPlaceBy, castToCollection, parallelStream, spliterator, stream, sumByDouble, sumByFloat, sumByInt, sumByLong
forEach, forEachWith, forEachWithIndex
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countBy, countByEach, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectWith, forEach, getAny, getFirst, getLast, getOnly, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, isEmpty, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, reduce, reject, rejectWith, select, selectWith, size, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex
public ImmutableBag<T> newWithoutAll(Iterable<? extends T> elements)
ImmutableCollection
withoutAll
method in MutableCollection
with the difference that a new copy of this collection with the elements removed will be returned.newWithoutAll
in interface ImmutableBag<T>
newWithoutAll
in interface ImmutableCollection<T>
public ImmutableBag<T> toImmutable()
toImmutable
in interface Bag<T>
public ImmutableBag<T> tap(Procedure<? super T> procedure)
RichIterable
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()); } });
tap
in interface Bag<T>
tap
in interface ImmutableBag<T>
tap
in interface ImmutableBagIterable<T>
tap
in interface ImmutableCollection<T>
tap
in interface RichIterable<T>
tap
in interface UnsortedBag<T>
RichIterable.each(Procedure)
,
RichIterable.forEach(Procedure)
public <P> ImmutableBag<T> selectWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterable
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));
selectWith
in interface Bag<T>
selectWith
in interface ImmutableBag<T>
selectWith
in interface ImmutableBagIterable<T>
selectWith
in interface ImmutableCollection<T>
selectWith
in interface RichIterable<T>
selectWith
in interface UnsortedBag<T>
predicate
- a Predicate2
to use as the select criteriaparameter
- a parameter to pass in for evaluation of the second argument P
in predicate
RichIterable.select(Predicate)
public <P> ImmutableBag<T> rejectWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterable
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));
rejectWith
in interface Bag<T>
rejectWith
in interface ImmutableBag<T>
rejectWith
in interface ImmutableBagIterable<T>
rejectWith
in interface ImmutableCollection<T>
rejectWith
in interface RichIterable<T>
rejectWith
in interface UnsortedBag<T>
predicate
- a Predicate2
to use as the select criteriaparameter
- a parameter to pass in for evaluation of the second argument P
in predicate
RichIterable.select(Predicate)
public PartitionImmutableBag<T> partition(Predicate<? super T> predicate)
RichIterable
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"); } });
partition
in interface Bag<T>
partition
in interface ImmutableBag<T>
partition
in interface ImmutableBagIterable<T>
partition
in interface ImmutableCollection<T>
partition
in interface RichIterable<T>
partition
in interface UnsortedBag<T>
public <P> PartitionImmutableBag<T> partitionWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterable
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");
partitionWith
in interface Bag<T>
partitionWith
in interface ImmutableBag<T>
partitionWith
in interface ImmutableBagIterable<T>
partitionWith
in interface ImmutableCollection<T>
partitionWith
in interface RichIterable<T>
public <V> ImmutableBag<V> countBy(Function<? super T,? extends V> function)
RichIterable
countBy
in interface ImmutableBag<T>
countBy
in interface ImmutableCollection<T>
countBy
in interface RichIterable<T>
countBy
in class AbstractImmutableBagIterable<T>
public <V,P> ImmutableBag<V> countByWith(Function2<? super T,? super P,? extends V> function, P parameter)
RichIterable
countByWith
in interface ImmutableBag<T>
countByWith
in interface ImmutableCollection<T>
countByWith
in interface RichIterable<T>
countByWith
in class AbstractImmutableBagIterable<T>
public <V> ImmutableBag<V> countByEach(Function<? super T,? extends Iterable<V>> function)
RichIterable
countByEach
in interface ImmutableBag<T>
countByEach
in interface ImmutableCollection<T>
countByEach
in interface RichIterable<T>
countByEach
in class AbstractImmutableBagIterable<T>
public <V> ImmutableBag<V> collectWithOccurrences(ObjectIntToObjectFunction<? super T,? extends V> function)
Bag
collectWithOccurrences
in interface Bag<T>
collectWithOccurrences
in interface ImmutableBag<T>
collectWithOccurrences
in interface ImmutableBagIterable<T>
collectWithOccurrences
in interface UnsortedBag<T>
public <P,V> ImmutableBag<V> collectWith(Function2<? super T,? super P,? extends V> function, P parameter)
RichIterable
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));
collectWith
in interface ImmutableBag<T>
collectWith
in interface ImmutableCollection<T>
collectWith
in interface RichIterable<T>
collectWith
in interface UnsortedBag<T>
function
- A Function2
to use as the collect transformation functionparameter
- A parameter to pass in for evaluation of the second argument P
in function
RichIterable
that contains the transformed elements returned by Function2.value(Object, Object)
RichIterable.collect(Function)
public ImmutableBooleanBag collectBoolean(BooleanFunction<? super T> booleanFunction)
RichIterable
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(); } });
collectBoolean
in interface ImmutableBag<T>
collectBoolean
in interface ImmutableCollection<T>
collectBoolean
in interface RichIterable<T>
collectBoolean
in interface UnsortedBag<T>
public ImmutableByteBag collectByte(ByteFunction<? super T> byteFunction)
RichIterable
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(); } });
collectByte
in interface ImmutableBag<T>
collectByte
in interface ImmutableCollection<T>
collectByte
in interface RichIterable<T>
collectByte
in interface UnsortedBag<T>
public ImmutableCharBag collectChar(CharFunction<? super T> charFunction)
RichIterable
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(); } });
collectChar
in interface ImmutableBag<T>
collectChar
in interface ImmutableCollection<T>
collectChar
in interface RichIterable<T>
collectChar
in interface UnsortedBag<T>
public ImmutableDoubleBag collectDouble(DoubleFunction<? super T> doubleFunction)
RichIterable
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(); } });
collectDouble
in interface ImmutableBag<T>
collectDouble
in interface ImmutableCollection<T>
collectDouble
in interface RichIterable<T>
collectDouble
in interface UnsortedBag<T>
public ImmutableFloatBag collectFloat(FloatFunction<? super T> floatFunction)
RichIterable
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(); } });
collectFloat
in interface ImmutableBag<T>
collectFloat
in interface ImmutableCollection<T>
collectFloat
in interface RichIterable<T>
collectFloat
in interface UnsortedBag<T>
public ImmutableIntBag collectInt(IntFunction<? super T> intFunction)
RichIterable
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(); } });
collectInt
in interface ImmutableBag<T>
collectInt
in interface ImmutableCollection<T>
collectInt
in interface RichIterable<T>
collectInt
in interface UnsortedBag<T>
public ImmutableLongBag collectLong(LongFunction<? super T> longFunction)
RichIterable
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(); } });
collectLong
in interface ImmutableBag<T>
collectLong
in interface ImmutableCollection<T>
collectLong
in interface RichIterable<T>
collectLong
in interface UnsortedBag<T>
public ImmutableShortBag collectShort(ShortFunction<? super T> shortFunction)
RichIterable
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(); } });
collectShort
in interface ImmutableBag<T>
collectShort
in interface ImmutableCollection<T>
collectShort
in interface RichIterable<T>
collectShort
in interface UnsortedBag<T>
public ImmutableList<ObjectIntPair<T>> topOccurrences(int n)
Bag
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.topOccurrences
in interface Bag<T>
topOccurrences
in interface ImmutableBag<T>
public ImmutableList<ObjectIntPair<T>> bottomOccurrences(int n)
Bag
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.bottomOccurrences
in interface Bag<T>
bottomOccurrences
in interface ImmutableBag<T>
public <V> ImmutableMap<V,T> groupByUniqueKey(Function<? super T,? extends V> function)
RichIterable
groupByUniqueKey
in interface ImmutableCollection<T>
groupByUniqueKey
in interface RichIterable<T>
RichIterable.groupBy(Function)
public RichIterable<RichIterable<T>> chunk(int size)
RichIterable
chunk
in interface RichIterable<T>
size
- the number of elements per chunkRichIterable
containing RichIterable
s of size size
, except the last will be
truncated if the elements don't divide evenly.Copyright © 2004–2019. All rights reserved.