java.lang.Iterable<T>, Bag<T>, ImmutableBag<T>, ImmutableBagIterable<T>, UnsortedBag<T>, ImmutableCollection<T>, InternalIterable<T>, RichIterable<T>ImmutableArrayBag, ImmutableHashBagpublic 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> |
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,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(java.lang.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. |
ImmutableSet<T> |
selectUnique() |
Returns a set containing all elements of the bag that have exactly one occurrence.
|
<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, toStringOfItemToCountadd, addAll, aggregateBy, aggregateInPlaceBy, castToCollection, clear, parallelStream, remove, removeAll, retainAll, spliterator, stream, sumByDouble, sumByFloat, sumByInt, sumByLongallSatisfy, 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, toMap, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSetBy, toString, zip, zipWithIndexcollectWithOccurrences, equals, forEachWithOccurrences, hashCode, occurrencesOf, reduceInPlace, reduceInPlace, sizeDistinct, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, toStringOfItemToCountcontains, containsAll, equals, hashCode, isEmpty, iterator, removeIf, size, toArray, toArraycollect, collectIf, flatCollect, flatCollectWith, groupBy, groupByEach, newWith, newWithAll, newWithout, reject, select, selectByOccurrences, selectDuplicates, selectInstancesOf, zip, zipWithIndextoMapOfItemToCountaggregateBy, aggregateInPlaceBy, castToCollection, parallelStream, spliterator, stream, sumByDouble, sumByFloat, sumByInt, sumByLongforEach, forEach, forEachWith, forEachWithIndexequals, getClass, hashCode, notify, notifyAll, wait, wait, waitallSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countBy, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectWith, 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, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndexpublic ImmutableBag<T> newWithoutAll(java.lang.Iterable<? extends T> elements)
ImmutableCollectionwithoutAll 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)
RichIterablethis.
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),
InternalIterable.forEach(Procedure)public <P> ImmutableBag<T> selectWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterableRichIterable.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 predicateRichIterable.select(Predicate)public <P> ImmutableBag<T> rejectWith(Predicate2<? super T,? super P> predicate, P parameter)
RichIterableRichIterable.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 predicateRichIterable.select(Predicate)public PartitionImmutableBag<T> partition(Predicate<? super T> predicate)
RichIterableExample 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)
RichIterableExample 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)
RichIterablecountBy 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)
RichIterablecountByWith in interface ImmutableBag<T>countByWith in interface ImmutableCollection<T>countByWith in interface RichIterable<T>countByWith in class AbstractImmutableBagIterable<T>public <P,V> ImmutableBag<V> collectWith(Function2<? super T,? super P,? extends V> function, P parameter)
RichIterableRichIterable.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 functionRichIterable that contains the transformed elements returned by Function2.value(Object, Object)RichIterable.collect(Function)public ImmutableBooleanBag collectBoolean(BooleanFunction<? super T> booleanFunction)
RichIterableboolean 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)
RichIterablebyte 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)
RichIterablechar 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)
RichIterabledouble 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)
RichIterablefloat 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)
RichIterableint 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)
RichIterablelong 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)
RichIterableshort 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)
Bagcount 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)
Bagcount 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)
RichIterablegroupByUniqueKey in interface ImmutableCollection<T>groupByUniqueKey in interface RichIterable<T>RichIterable.groupBy(Function)public RichIterable<RichIterable<T>> chunk(int size)
RichIterablechunk in interface RichIterable<T>size - the number of elements per chunkRichIterable containing RichIterables of size size, except the last will be
truncated if the elements don't divide evenly.public ImmutableSet<T> selectUnique()
BagselectUnique in interface Bag<T>selectUnique in interface ImmutableBag<T>selectUnique in interface ImmutableBagIterable<T>selectUnique in interface UnsortedBag<T>selectUnique in class AbstractImmutableBagIterable<T>Copyright © 2004–2018. All rights reserved.