Package | Description |
---|---|
org.eclipse.collections.api |
This package contains interfaces for Eclipse Collections API.
|
org.eclipse.collections.api.bag |
This package contains interfaces for Bag API.
|
org.eclipse.collections.api.bag.primitive |
This package contains API for Primitive Bags with Mutable and Immutable variants.
|
org.eclipse.collections.api.bag.sorted |
This package contains interfaces for SortedBag API.
|
org.eclipse.collections.api.collection | |
org.eclipse.collections.api.factory.bag |
This package contains factory API for creating instance of type
Bag . |
org.eclipse.collections.api.factory.bag.strategy | |
org.eclipse.collections.api.map |
This package contains interfaces for map API which enhance the performance and functionality of
Map |
org.eclipse.collections.api.map.primitive |
This package contains API for primitive to primitive maps, primitive to object maps and object to primitive maps with mutable and immutable variants.
|
org.eclipse.collections.api.multimap.bag |
This package contains interfaces for
BagMultimap . |
org.eclipse.collections.api.partition.bag |
This package contains interfaces for
PartitionBag . |
org.eclipse.collections.api.stack |
This package contains interfaces for stack API.
|
org.eclipse.collections.impl |
This package contains implementations for Eclipse Collections API.
|
org.eclipse.collections.impl.bag | |
org.eclipse.collections.impl.bag.immutable |
This package contains implementations of the
ImmutableBag interface. |
org.eclipse.collections.impl.bag.mutable |
This package contains implementations of the
MutableBag interface. |
org.eclipse.collections.impl.bag.mutable.primitive |
This package contains implementations of the mutable primitive bag interfaces.
|
org.eclipse.collections.impl.bag.sorted.mutable |
This package contains implementations of
MutableSortedBag . |
org.eclipse.collections.impl.bag.strategy.mutable |
This package contains implementations of bags with user defined
HashingStrategy s. |
org.eclipse.collections.impl.bimap | |
org.eclipse.collections.impl.bimap.mutable |
This package contains implementations of the
MutableBiMap interface. |
org.eclipse.collections.impl.block.factory |
This package contains factory implementations for
Function , Predicate , SerializableComparator and Procedure . |
org.eclipse.collections.impl.block.procedure |
This package contains implementations of
Procedure and Procedure2 . |
org.eclipse.collections.impl.collection | |
org.eclipse.collections.impl.collection.mutable |
This package contains implementations of the
MutableCollection interface. |
org.eclipse.collections.impl.collector | |
org.eclipse.collections.impl.factory |
This package contains static utilities for creating mutable and immutable collection factories.
|
org.eclipse.collections.impl.lazy.parallel | |
org.eclipse.collections.impl.lazy.parallel.bag | |
org.eclipse.collections.impl.list |
This package contains implementations of the
ListIterable interface. |
org.eclipse.collections.impl.map |
This package contains implementations of the
MapIterable interface. |
org.eclipse.collections.impl.map.mutable |
This package contains implementations of the
MutableMap interface. |
org.eclipse.collections.impl.map.mutable.primitive |
This package contains implementations of the mutable primitive-primitive, primitive-object and object-primitive map interfaces.
|
org.eclipse.collections.impl.map.ordered.mutable | |
org.eclipse.collections.impl.map.sorted.mutable |
This package contains implementations of the
MutableSortedMap interface. |
org.eclipse.collections.impl.multimap.bag |
This package contains implementations of the
BagMultimap interface. |
org.eclipse.collections.impl.partition.bag |
This package contains implementations of the
PartitionBag interface. |
org.eclipse.collections.impl.stack.mutable |
This package contains implementations of the
MutableStack interface. |
org.eclipse.collections.impl.utility |
This package contains static utilities that provide iteration pattern implementations which work with JCF collections.
|
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
ParallelIterable.toBag() |
|
MutableBag<T> |
RichIterable.toBag() |
Converts the collection to the default MutableBag implementation.
|
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
MutableBag.asSynchronized() |
|
MutableBag<T> |
MutableBag.asUnmodifiable() |
|
<V> MutableBag<V> |
MutableBag.collect(Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
MutableBag.collectIf(Predicate<? super T> predicate,
Function<? super T,? extends V> function) |
|
<P,V> MutableBag<V> |
MutableBag.collectWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
default <V> MutableBag<V> |
MutableBag.countBy(Function<? super T,? extends V> function) |
|
default <V,P> MutableBag<V> |
MutableBag.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
<V> MutableBag<V> |
MutableBag.flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function) |
|
default <P,V> MutableBag<V> |
MutableBag.flatCollectWith(Function2<? super T,? super P,? extends java.lang.Iterable<V>> function,
P parameter) |
|
MutableBag<T> |
MutableBag.newEmpty() |
|
MutableBag<T> |
MutableBag.reject(Predicate<? super T> predicate) |
|
<P> MutableBag<T> |
MutableBag.rejectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
MutableBag<T> |
MutableBag.select(Predicate<? super T> predicate) |
|
MutableBag<T> |
MutableBag.selectByOccurrences(IntPredicate predicate) |
|
default MutableBag<T> |
MutableBag.selectDuplicates() |
|
<S> MutableBag<S> |
MutableBag.selectInstancesOf(java.lang.Class<S> clazz) |
|
<P> MutableBag<T> |
MutableBag.selectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
MutableBag<T> |
MutableBag.tap(Procedure<? super T> procedure) |
|
MutableBag<T> |
MutableBag.with(T element) |
|
MutableBag<T> |
MutableBag.withAll(java.lang.Iterable<? extends T> elements) |
|
MutableBag<T> |
MutableBag.without(T element) |
|
MutableBag<T> |
MutableBag.withoutAll(java.lang.Iterable<? extends T> elements) |
|
<S> MutableBag<Pair<T,S>> |
MutableBag.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
Modifier and Type | Method | Description |
---|---|---|
<V> MutableBag<V> |
MutableBooleanBag.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableByteBag.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableCharBag.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableDoubleBag.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableFloatBag.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableIntBag.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableLongBag.collect(LongToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableShortBag.collect(ShortToObjectFunction<? extends V> function) |
Modifier and Type | Method | Description |
---|---|---|
default <V> MutableBag<V> |
MutableSortedBag.countBy(Function<? super T,? extends V> function) |
|
default <V,P> MutableBag<V> |
MutableSortedBag.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
Modifier and Type | Method | Description |
---|---|---|
default <V> MutableBag<V> |
MutableCollection.countBy(Function<? super T,? extends V> function) |
|
default <V,P> MutableBag<V> |
MutableCollection.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
Modifier and Type | Method | Description |
---|---|---|
<T> MutableBag<T> |
MutableBagFactory.empty() |
|
<T> MutableBag<T> |
MutableBagFactory.of() |
Same as
MutableBagFactory.empty() . |
<T> MutableBag<T> |
MutableBagFactory.of(T... elements) |
Same as
MutableBagFactory.with(Object[]) . |
<T> MutableBag<T> |
MutableBagFactory.ofAll(java.lang.Iterable<? extends T> items) |
Same as
MutableBagFactory.withAll(Iterable) . |
<T> MutableBag<T> |
MutableBagFactory.with() |
Same as
MutableBagFactory.empty() . |
<T> MutableBag<T> |
MutableBagFactory.with(T... elements) |
|
<T> MutableBag<T> |
MutableBagFactory.withAll(java.lang.Iterable<? extends T> items) |
Modifier and Type | Method | Description |
---|---|---|
<T> MutableBag<T> |
MutableHashingStrategyBagFactory.empty(HashingStrategy<? super T> hashingStrategy) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactory.of(HashingStrategy<? super T> hashingStrategy) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactory.of(HashingStrategy<? super T> hashingStrategy,
T... items) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactory.ofAll(HashingStrategy<? super T> hashingStrategy,
java.lang.Iterable<? extends T> items) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactory.with(HashingStrategy<? super T> hashingStrategy) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactory.with(HashingStrategy<? super T> hashingStrategy,
T... items) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactory.withAll(HashingStrategy<? super T> hashingStrategy,
java.lang.Iterable<? extends T> items) |
Modifier and Type | Method | Description |
---|---|---|
<R> MutableBag<R> |
MutableMap.collect(Function<? super V,? extends R> function) |
|
<R> MutableBag<R> |
MutableMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends R> function) |
|
<P,V1> MutableBag<V1> |
MutableMap.collectWith(Function2<? super V,? super P,? extends V1> function,
P parameter) |
|
default <V1> MutableBag<V1> |
MutableMapIterable.countBy(Function<? super V,? extends V1> function) |
|
default <V1,P> MutableBag<V1> |
MutableMapIterable.countByWith(Function2<? super V,? super P,? extends V1> function,
P parameter) |
|
<R> MutableBag<R> |
MutableMap.flatCollect(Function<? super V,? extends java.lang.Iterable<R>> function) |
|
default <P,R> MutableBag<R> |
MutableMap.flatCollectWith(Function2<? super V,? super P,? extends java.lang.Iterable<R>> function,
P parameter) |
|
MutableBag<V> |
MutableMap.reject(Predicate<? super V> predicate) |
|
<P> MutableBag<V> |
MutableMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
MutableBag<V> |
MutableMap.select(Predicate<? super V> predicate) |
|
<S> MutableBag<S> |
MutableMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<P> MutableBag<V> |
MutableMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<S> MutableBag<Pair<V,S>> |
MutableMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
Modifier and Type | Method | Description |
---|---|---|
<V> MutableBag<V> |
MutableBooleanValuesMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableByteValuesMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableCharValuesMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableDoubleValuesMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableFloatValuesMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableIntValuesMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
MutableLongValuesMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
MutablePrimitiveObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
MutableShortValuesMap.collect(ShortToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
MutablePrimitiveObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<P,VV> MutableBag<VV> |
MutablePrimitiveObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<VV> MutableBag<VV> |
MutablePrimitiveObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
default <P,VV> MutableBag<VV> |
MutablePrimitiveObjectMap.flatCollectWith(Function2<? super V,? super P,? extends java.lang.Iterable<VV>> function,
P parameter) |
|
MutableBag<V> |
MutablePrimitiveObjectMap.reject(Predicate<? super V> predicate) |
|
<P> MutableBag<V> |
MutablePrimitiveObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
MutableBag<V> |
MutablePrimitiveObjectMap.select(Predicate<? super V> predicate) |
|
<S> MutableBag<S> |
MutablePrimitiveObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<P> MutableBag<V> |
MutablePrimitiveObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<S> MutableBag<Pair<V,S>> |
MutablePrimitiveObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<V> |
MutableBagMultimap.get(K key) |
|
MutableBag<V> |
MutableBagMultimap.removeAll(java.lang.Object key) |
|
MutableBag<V> |
MutableBagMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
PartitionMutableBag.getRejected() |
|
MutableBag<T> |
PartitionMutableBag.getSelected() |
Modifier and Type | Method | Description |
---|---|---|
default <V> MutableBag<V> |
MutableStack.countBy(Function<? super T,? extends V> function) |
|
default <V,P> MutableBag<V> |
MutableStack.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
AbstractRichIterable.toBag() |
|
MutableBag<T> |
UnmodifiableRichIterable.toBag() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
AbstractBag.toBag() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
ImmutableHashBag.toBag() |
Modifier and Type | Class | Description |
---|---|---|
class |
AbstractHashBag<T> |
|
class |
AbstractMutableBag<T> |
|
class |
HashBag<T> |
A HashBag is a MutableBag which uses a Map as its underlying data store.
|
class |
MultiReaderHashBag<T> |
MultiReaderHashBag provides a thread-safe wrapper around a HashBag, using a ReentrantReadWriteLock.
|
class |
SynchronizedBag<T> |
A synchronized view of a
MutableBag . |
class |
UnmodifiableBag<T> |
An unmodifiable view of a bag.
|
Modifier and Type | Method | Description |
---|---|---|
static <E,B extends MutableBag<E>> |
SynchronizedBag.of(B bag) |
This method will take a MutableBag and wrap it directly in a SynchronizedBag.
|
static <E,B extends MutableBag<E>> |
SynchronizedBag.of(B bag,
java.lang.Object lock) |
This method will take a MutableBag and wrap it directly in a SynchronizedBag.
|
static <E,B extends MutableBag<E>> |
UnmodifiableBag.of(B bag) |
This method will take a MutableBag and wrap it directly in a UnmodifiableBag.
|
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
MultiReaderHashBag.asSynchronized() |
|
MutableBag<T> |
SynchronizedBag.asSynchronized() |
|
MutableBag<T> |
UnmodifiableBag.asSynchronized() |
|
MutableBag<T> |
MultiReaderHashBag.asUnmodifiable() |
|
MutableBag<T> |
SynchronizedBag.asUnmodifiable() |
|
MutableBag<T> |
UnmodifiableBag.asUnmodifiable() |
|
<V> MutableBag<V> |
AbstractMutableBag.collect(Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
MultiReaderHashBag.collect(Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedBag.collect(Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableBag.collect(Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableBag.collectIf(Predicate<? super T> predicate,
Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
MultiReaderHashBag.collectIf(Predicate<? super T> predicate,
Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedBag.collectIf(Predicate<? super T> predicate,
Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableBag.collectIf(Predicate<? super T> predicate,
Function<? super T,? extends V> function) |
|
<P,V> MutableBag<V> |
AbstractMutableBag.collectWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
<P,V> MutableBag<V> |
MultiReaderHashBag.collectWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
<P,V> MutableBag<V> |
SynchronizedBag.collectWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
<P,A> MutableBag<A> |
UnmodifiableBag.collectWith(Function2<? super T,? super P,? extends A> function,
P parameter) |
|
<V> MutableBag<V> |
AbstractMutableBag.countBy(Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableBagIterable.countBy(Function<? super T,? extends V> function) |
|
<V,P> MutableBag<V> |
AbstractMutableBag.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
<V,P> MutableBag<V> |
AbstractMutableBagIterable.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
<T> MutableBag<T> |
MultiReaderMutableBagFactory.empty() |
|
<T> MutableBag<T> |
MutableBagFactoryImpl.empty() |
|
<V> MutableBag<V> |
AbstractMutableBag.flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function) |
|
<V> MutableBag<V> |
MultiReaderHashBag.flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function) |
|
<V> MutableBag<V> |
SynchronizedBag.flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function) |
|
<V> MutableBag<V> |
UnmodifiableBag.flatCollect(Function<? super T,? extends java.lang.Iterable<V>> function) |
|
MutableBag<T> |
HashBag.newEmpty() |
|
MutableBag<T> |
MultiReaderHashBag.newEmpty() |
|
MutableBag<T> |
SynchronizedBag.newEmpty() |
|
MutableBag<T> |
UnmodifiableBag.newEmpty() |
|
<T> MutableBag<T> |
MultiReaderMutableBagFactory.of() |
|
<T> MutableBag<T> |
MultiReaderMutableBagFactory.of(T... items) |
|
<T> MutableBag<T> |
MutableBagFactoryImpl.of() |
|
<T> MutableBag<T> |
MutableBagFactoryImpl.of(T... elements) |
|
<T> MutableBag<T> |
MultiReaderMutableBagFactory.ofAll(java.lang.Iterable<? extends T> iterable) |
|
<T> MutableBag<T> |
MutableBagFactoryImpl.ofAll(java.lang.Iterable<? extends T> items) |
|
MutableBag<T> |
AbstractMutableBag.reject(Predicate<? super T> predicate) |
|
MutableBag<T> |
MultiReaderHashBag.reject(Predicate<? super T> predicate) |
|
MutableBag<T> |
SynchronizedBag.reject(Predicate<? super T> predicate) |
|
MutableBag<T> |
UnmodifiableBag.reject(Predicate<? super T> predicate) |
|
<P> MutableBag<T> |
AbstractMutableBag.rejectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
<P> MutableBag<T> |
MultiReaderHashBag.rejectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
<P> MutableBag<T> |
SynchronizedBag.rejectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
<P> MutableBag<T> |
UnmodifiableBag.rejectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
MutableBag<T> |
AbstractMutableBag.select(Predicate<? super T> predicate) |
|
MutableBag<T> |
MultiReaderHashBag.select(Predicate<? super T> predicate) |
|
MutableBag<T> |
SynchronizedBag.select(Predicate<? super T> predicate) |
|
MutableBag<T> |
UnmodifiableBag.select(Predicate<? super T> predicate) |
|
MutableBag<T> |
HashBag.selectByOccurrences(IntPredicate predicate) |
|
MutableBag<T> |
MultiReaderHashBag.selectByOccurrences(IntPredicate predicate) |
|
MutableBag<T> |
SynchronizedBag.selectByOccurrences(IntPredicate predicate) |
|
MutableBag<T> |
UnmodifiableBag.selectByOccurrences(IntPredicate predicate) |
|
<S> MutableBag<S> |
AbstractMutableBag.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
MultiReaderHashBag.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedBag.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableBag.selectInstancesOf(java.lang.Class<S> clazz) |
|
<P> MutableBag<T> |
AbstractMutableBag.selectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
<P> MutableBag<T> |
MultiReaderHashBag.selectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
<P> MutableBag<T> |
SynchronizedBag.selectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
<P> MutableBag<T> |
UnmodifiableBag.selectWith(Predicate2<? super T,? super P> predicate,
P parameter) |
|
MutableBag<T> |
AbstractMutableBag.tap(Procedure<? super T> procedure) |
|
MutableBag<T> |
MultiReaderHashBag.tap(Procedure<? super T> procedure) |
|
MutableBag<T> |
SynchronizedBag.tap(Procedure<? super T> procedure) |
|
MutableBag<T> |
UnmodifiableBag.tap(Procedure<? super T> procedure) |
|
MutableBag<T> |
MultiReaderHashBag.with(T element) |
|
<T> MutableBag<T> |
MultiReaderMutableBagFactory.with() |
|
<T> MutableBag<T> |
MultiReaderMutableBagFactory.with(T... items) |
|
<T> MutableBag<T> |
MutableBagFactoryImpl.with() |
|
<T> MutableBag<T> |
MutableBagFactoryImpl.with(T... elements) |
|
MutableBag<T> |
SynchronizedBag.with(T element) |
|
MutableBag<T> |
UnmodifiableBag.with(T element) |
|
MutableBag<T> |
MultiReaderHashBag.withAll(java.lang.Iterable<? extends T> elements) |
|
<T> MutableBag<T> |
MultiReaderMutableBagFactory.withAll(java.lang.Iterable<? extends T> iterable) |
|
<T> MutableBag<T> |
MutableBagFactoryImpl.withAll(java.lang.Iterable<? extends T> items) |
|
MutableBag<T> |
SynchronizedBag.withAll(java.lang.Iterable<? extends T> elements) |
|
MutableBag<T> |
UnmodifiableBag.withAll(java.lang.Iterable<? extends T> elements) |
|
MutableBag<T> |
MultiReaderHashBag.without(T element) |
|
MutableBag<T> |
SynchronizedBag.without(T element) |
|
MutableBag<T> |
UnmodifiableBag.without(T element) |
|
MutableBag<T> |
MultiReaderHashBag.withoutAll(java.lang.Iterable<? extends T> elements) |
|
MutableBag<T> |
SynchronizedBag.withoutAll(java.lang.Iterable<? extends T> elements) |
|
MutableBag<T> |
UnmodifiableBag.withoutAll(java.lang.Iterable<? extends T> elements) |
|
<S> MutableBag<Pair<T,S>> |
AbstractMutableBag.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<T,S>> |
MultiReaderHashBag.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<T,S>> |
SynchronizedBag.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<T,S>> |
UnmodifiableBag.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
Modifier and Type | Method | Description |
---|---|---|
void |
MultiReaderHashBag.withReadLockAndDelegate(Procedure<MutableBag<T>> procedure) |
|
void |
MultiReaderHashBag.withWriteLockAndDelegate(Procedure<MutableBag<T>> procedure) |
Constructor | Description |
---|---|
SynchronizedBag(MutableBag<T> bag,
java.lang.Object newLock) |
Modifier and Type | Method | Description |
---|---|---|
<V> MutableBag<V> |
BooleanHashBag.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
ByteHashBag.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
CharHashBag.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
DoubleHashBag.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
FloatHashBag.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
IntHashBag.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
LongHashBag.collect(LongToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
ShortHashBag.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedBooleanBag.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedByteBag.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharBag.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleBag.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatBag.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntBag.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongBag.collect(LongToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortBag.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableBooleanBag.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteBag.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharBag.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleBag.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatBag.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntBag.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongBag.collect(LongToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortBag.collect(ShortToObjectFunction<? extends V> function) |
Modifier and Type | Method | Description |
---|---|---|
<V> MutableBag<V> |
AbstractMutableSortedBag.countBy(Function<? super T,? extends V> function) |
|
<V,P> MutableBag<V> |
AbstractMutableSortedBag.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
Modifier and Type | Class | Description |
---|---|---|
class |
HashBagWithHashingStrategy<T> |
Modifier and Type | Method | Description |
---|---|---|
<T> MutableBag<T> |
MutableHashingStrategyBagFactoryImpl.empty(HashingStrategy<? super T> hashingStrategy) |
|
MutableBag<T> |
HashBagWithHashingStrategy.newEmpty() |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactoryImpl.of(HashingStrategy<? super T> hashingStrategy) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactoryImpl.of(HashingStrategy<? super T> hashingStrategy,
T... items) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactoryImpl.ofAll(HashingStrategy<? super T> hashingStrategy,
java.lang.Iterable<? extends T> items) |
|
MutableBag<T> |
HashBagWithHashingStrategy.selectByOccurrences(IntPredicate predicate) |
|
MutableBag<T> |
HashBagWithHashingStrategy.with(T element) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactoryImpl.with(HashingStrategy<? super T> hashingStrategy) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactoryImpl.with(HashingStrategy<? super T> hashingStrategy,
T... items) |
|
MutableBag<T> |
HashBagWithHashingStrategy.withAll(java.lang.Iterable<? extends T> elements) |
|
<T> MutableBag<T> |
MutableHashingStrategyBagFactoryImpl.withAll(HashingStrategy<? super T> hashingStrategy,
java.lang.Iterable<? extends T> items) |
|
MutableBag<T> |
HashBagWithHashingStrategy.without(T element) |
|
MutableBag<T> |
HashBagWithHashingStrategy.withoutAll(java.lang.Iterable<? extends T> elements) |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<V> |
AbstractBiMap.toBag() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<V> |
UnmodifiableBiMap.toBag() |
Modifier and Type | Method | Description |
---|---|---|
static <T> Function0<MutableBag<T>> |
Functions0.newHashBag() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
BagAddOccurrencesProcedure.getResult() |
Modifier and Type | Method | Description |
---|---|---|
static <T> BagAddOccurrencesProcedure<T> |
BagAddOccurrencesProcedure.on(MutableBag<T> mutableBag) |
Constructor | Description |
---|---|
BagAddOccurrencesProcedure(MutableBag<T> mutableBag) |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
AbstractSynchronizedRichIterable.toBag() |
Modifier and Type | Method | Description |
---|---|---|
<V> MutableBag<V> |
AbstractMutableCollection.countBy(Function<? super T,? extends V> function) |
|
<V> MutableBag<V> |
AbstractSynchronizedMutableCollection.countBy(Function<? super T,? extends V> function) |
|
<V,P> MutableBag<V> |
AbstractMutableCollection.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
<V,P> MutableBag<V> |
AbstractSynchronizedMutableCollection.countByWith(Function2<? super T,? super P,? extends V> function,
P parameter) |
|
MutableBag<T> |
AbstractCollectionAdapter.toBag() |
|
MutableBag<T> |
AbstractMultiReaderMutableCollection.toBag() |
|
MutableBag<T> |
AbstractUnmodifiableMutableCollection.toBag() |
Modifier and Type | Method | Description |
---|---|---|
static <T,K> java.util.stream.Collector<T,?,MutableBag<K>> |
Collectors2.countBy(Function<? super T,? extends K> function) |
Returns the counts of all of the values returned by applying the specified function to each
item of the Stream.
|
static <T,K> java.util.stream.Collector<T,?,MutableBag<K>> |
Collectors2.countByEach(Function<? super T,? extends java.lang.Iterable<K>> function) |
Same as
Collectors2.countBy(Function) , except the result of applying the specified function will return a
collection of keys for each value. |
static <T> java.util.stream.Collector<T,?,MutableBag<T>> |
Collectors2.toBag() |
Returns the elements as a MutableBag.
|
Modifier and Type | Method | Description |
---|---|---|
static <T> MutableBag<T> |
Iterables.mBag() |
|
static <T> MutableBag<T> |
Iterables.mBag(T... elements) |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
AbstractMultiReaderParallelIterable.toBag() |
|
MutableBag<T> |
AbstractParallelIterable.toBag() |
|
MutableBag<T> |
AbstractSynchronizedParallelIterable.toBag() |
|
MutableBag<T> |
NonParallelIterable.toBag() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
AbstractParallelUnsortedBag.toBag() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<java.lang.Integer> |
Interval.toBag() |
Modifier and Type | Method | Description |
---|---|---|
<V1> MutableBag<V1> |
AbstractSynchronizedMapIterable.countBy(Function<? super V,? extends V1> function) |
|
<V1,P> MutableBag<V1> |
AbstractSynchronizedMapIterable.countByWith(Function2<? super V,? super P,? extends V1> function,
P parameter) |
Modifier and Type | Method | Description |
---|---|---|
<R> MutableBag<R> |
AbstractMutableMap.collect(Function<? super V,? extends R> function) |
|
<A> MutableBag<A> |
SynchronizedMutableMap.collect(Function<? super V,? extends A> function) |
|
<R> MutableBag<R> |
UnmodifiableMutableMap.collect(Function<? super V,? extends R> function) |
|
<R> MutableBag<R> |
AbstractMutableMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends R> function) |
|
<A> MutableBag<A> |
SynchronizedMutableMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends A> function) |
|
<R> MutableBag<R> |
UnmodifiableMutableMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends R> function) |
|
<P,VV> MutableBag<VV> |
AbstractMutableMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,A> MutableBag<A> |
SynchronizedMutableMap.collectWith(Function2<? super V,? super P,? extends A> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableMutableMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<V1> MutableBag<V1> |
AbstractMutableMapIterable.countBy(Function<? super V,? extends V1> function) |
|
<V1,P> MutableBag<V1> |
AbstractMutableMapIterable.countByWith(Function2<? super V,? super P,? extends V1> function,
P parameter) |
|
<R> MutableBag<R> |
AbstractMutableMap.flatCollect(Function<? super V,? extends java.lang.Iterable<R>> function) |
|
<A> MutableBag<A> |
SynchronizedMutableMap.flatCollect(Function<? super V,? extends java.lang.Iterable<A>> function) |
|
<R> MutableBag<R> |
UnmodifiableMutableMap.flatCollect(Function<? super V,? extends java.lang.Iterable<R>> function) |
|
MutableBag<V> |
AbstractMutableMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedMutableMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableMutableMap.reject(Predicate<? super V> predicate) |
|
<P> MutableBag<V> |
AbstractMutableMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedMutableMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableMutableMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
MutableBag<V> |
AbstractMutableMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedMutableMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableMutableMap.select(Predicate<? super V> predicate) |
|
<S> MutableBag<S> |
AbstractMutableMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedMutableMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableMutableMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<P> MutableBag<V> |
AbstractMutableMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedMutableMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableMutableMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
MutableBag<V> |
UnmodifiableMutableMap.toBag() |
|
<S> MutableBag<Pair<V,S>> |
AbstractMutableMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedMutableMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableMutableMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 6.0. Use
OrderedIterable.zip(Iterable) instead. |
Modifier and Type | Method | Description |
---|---|---|
<V> MutableBag<V> |
AbstractMutableBooleanValuesMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableByteValuesMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableCharValuesMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableDoubleValuesMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableFloatValuesMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableIntValuesMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableLongValuesMap.collect(LongToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
AbstractMutableShortValuesMap.collect(ShortToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
ByteObjectHashMap.collect(Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
CharObjectHashMap.collect(Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
DoubleObjectHashMap.collect(Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
FloatObjectHashMap.collect(Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
IntObjectHashMap.collect(Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
LongObjectHashMap.collect(Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
ShortObjectHashMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedByteBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedByteByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedByteCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedByteDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedByteFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedByteIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedByteLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
SynchronizedByteObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedByteShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedCharLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
SynchronizedCharObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedCharShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
SynchronizedDoubleObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedDoubleShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedFloatLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
SynchronizedFloatObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedFloatShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedIntLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
SynchronizedIntObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedIntShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedLongLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
SynchronizedLongObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedLongShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
SynchronizedShortLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
SynchronizedShortObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
SynchronizedShortShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableByteLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
UnmodifiableByteObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
UnmodifiableByteShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableCharLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
UnmodifiableCharObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
UnmodifiableCharShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
UnmodifiableDoubleObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
UnmodifiableDoubleShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
UnmodifiableFloatObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
UnmodifiableFloatShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableIntLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
UnmodifiableIntObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
UnmodifiableIntShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableLongLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
UnmodifiableLongObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
UnmodifiableLongShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortBooleanMap.collect(BooleanToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortByteMap.collect(ByteToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortCharMap.collect(CharToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortDoubleMap.collect(DoubleToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortFloatMap.collect(FloatToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortIntMap.collect(IntToObjectFunction<? extends V> function) |
|
<V> MutableBag<V> |
UnmodifiableShortLongMap.collect(LongToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
UnmodifiableShortObjectMap.collect(Function<? super V,? extends VV> function) |
|
<V> MutableBag<V> |
UnmodifiableShortShortMap.collect(ShortToObjectFunction<? extends V> function) |
|
<VV> MutableBag<VV> |
ByteObjectHashMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
CharObjectHashMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
DoubleObjectHashMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
FloatObjectHashMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
IntObjectHashMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
LongObjectHashMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
ShortObjectHashMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
SynchronizedByteObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
SynchronizedCharObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
SynchronizedDoubleObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
SynchronizedFloatObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
SynchronizedIntObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
SynchronizedLongObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
SynchronizedShortObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
UnmodifiableByteObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
UnmodifiableCharObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
UnmodifiableDoubleObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
UnmodifiableFloatObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
UnmodifiableIntObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
UnmodifiableLongObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<VV> MutableBag<VV> |
UnmodifiableShortObjectMap.collectIf(Predicate<? super V> predicate,
Function<? super V,? extends VV> function) |
|
<P,VV> MutableBag<VV> |
ByteObjectHashMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
CharObjectHashMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
DoubleObjectHashMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
FloatObjectHashMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
IntObjectHashMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
LongObjectHashMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
ShortObjectHashMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
SynchronizedByteObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
SynchronizedCharObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
SynchronizedDoubleObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
SynchronizedFloatObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
SynchronizedIntObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
SynchronizedLongObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
SynchronizedShortObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableByteObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableCharObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableDoubleObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableFloatObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableIntObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableLongObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<P,VV> MutableBag<VV> |
UnmodifiableShortObjectMap.collectWith(Function2<? super V,? super P,? extends VV> function,
P parameter) |
|
<VV> MutableBag<VV> |
ByteObjectHashMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
CharObjectHashMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
DoubleObjectHashMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
FloatObjectHashMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
IntObjectHashMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
LongObjectHashMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
ShortObjectHashMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
SynchronizedByteObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
SynchronizedCharObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
SynchronizedDoubleObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
SynchronizedFloatObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
SynchronizedIntObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
SynchronizedLongObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
SynchronizedShortObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
UnmodifiableByteObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
UnmodifiableCharObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
UnmodifiableDoubleObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
UnmodifiableFloatObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
UnmodifiableIntObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
UnmodifiableLongObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
<VV> MutableBag<VV> |
UnmodifiableShortObjectMap.flatCollect(Function<? super V,? extends java.lang.Iterable<VV>> function) |
|
MutableBag<V> |
ByteObjectHashMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
CharObjectHashMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
DoubleObjectHashMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
FloatObjectHashMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
IntObjectHashMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
LongObjectHashMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
ShortObjectHashMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedByteObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedCharObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedDoubleObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedFloatObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedIntObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedLongObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedShortObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableByteObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableCharObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableDoubleObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableFloatObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableIntObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableLongObjectMap.reject(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableShortObjectMap.reject(Predicate<? super V> predicate) |
|
<P> MutableBag<V> |
ByteObjectHashMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
CharObjectHashMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
DoubleObjectHashMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
FloatObjectHashMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
IntObjectHashMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
LongObjectHashMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
ShortObjectHashMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedByteObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedCharObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedDoubleObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedFloatObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedIntObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedLongObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedShortObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableByteObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableCharObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableDoubleObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableFloatObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableIntObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableLongObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableShortObjectMap.rejectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
MutableBag<V> |
ByteObjectHashMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
CharObjectHashMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
DoubleObjectHashMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
FloatObjectHashMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
IntObjectHashMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
LongObjectHashMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
ShortObjectHashMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedByteObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedCharObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedDoubleObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedFloatObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedIntObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedLongObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
SynchronizedShortObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableByteObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableCharObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableDoubleObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableFloatObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableIntObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableLongObjectMap.select(Predicate<? super V> predicate) |
|
MutableBag<V> |
UnmodifiableShortObjectMap.select(Predicate<? super V> predicate) |
|
<S> MutableBag<S> |
ByteObjectHashMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
CharObjectHashMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
DoubleObjectHashMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
FloatObjectHashMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
IntObjectHashMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
LongObjectHashMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
ShortObjectHashMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedByteObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedCharObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedDoubleObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedFloatObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedIntObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedLongObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
SynchronizedShortObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableByteObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableCharObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableDoubleObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableFloatObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableIntObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableLongObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<S> MutableBag<S> |
UnmodifiableShortObjectMap.selectInstancesOf(java.lang.Class<S> clazz) |
|
<P> MutableBag<V> |
ByteObjectHashMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
CharObjectHashMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
DoubleObjectHashMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
FloatObjectHashMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
IntObjectHashMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
LongObjectHashMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
ShortObjectHashMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedByteObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedCharObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedDoubleObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedFloatObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedIntObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedLongObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
SynchronizedShortObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableByteObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableCharObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableDoubleObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableFloatObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableIntObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableLongObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
<P> MutableBag<V> |
UnmodifiableShortObjectMap.selectWith(Predicate2<? super V,? super P> predicate,
P parameter) |
|
MutableBag<V> |
ByteObjectHashMap.toBag() |
|
MutableBag<V> |
CharObjectHashMap.toBag() |
|
MutableBag<V> |
DoubleObjectHashMap.toBag() |
|
MutableBag<V> |
FloatObjectHashMap.toBag() |
|
MutableBag<V> |
IntObjectHashMap.toBag() |
|
MutableBag<V> |
LongObjectHashMap.toBag() |
|
MutableBag<V> |
ShortObjectHashMap.toBag() |
|
MutableBag<V> |
SynchronizedByteObjectMap.toBag() |
|
MutableBag<V> |
SynchronizedCharObjectMap.toBag() |
|
MutableBag<V> |
SynchronizedDoubleObjectMap.toBag() |
|
MutableBag<V> |
SynchronizedFloatObjectMap.toBag() |
|
MutableBag<V> |
SynchronizedIntObjectMap.toBag() |
|
MutableBag<V> |
SynchronizedLongObjectMap.toBag() |
|
MutableBag<V> |
SynchronizedShortObjectMap.toBag() |
|
MutableBag<V> |
UnmodifiableByteObjectMap.toBag() |
|
MutableBag<V> |
UnmodifiableCharObjectMap.toBag() |
|
MutableBag<V> |
UnmodifiableDoubleObjectMap.toBag() |
|
MutableBag<V> |
UnmodifiableFloatObjectMap.toBag() |
|
MutableBag<V> |
UnmodifiableIntObjectMap.toBag() |
|
MutableBag<V> |
UnmodifiableLongObjectMap.toBag() |
|
MutableBag<V> |
UnmodifiableShortObjectMap.toBag() |
|
<S> MutableBag<Pair<V,S>> |
ByteObjectHashMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
CharObjectHashMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
DoubleObjectHashMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
FloatObjectHashMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
IntObjectHashMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
LongObjectHashMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
ShortObjectHashMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedByteObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedCharObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedDoubleObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedFloatObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedIntObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedLongObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
SynchronizedShortObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableByteObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableCharObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableDoubleObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableFloatObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableIntObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableLongObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
<S> MutableBag<Pair<V,S>> |
UnmodifiableShortObjectMap.zip(java.lang.Iterable<S> that) |
Deprecated.
in 7.0. Use
OrderedIterable.zip(Iterable) instead. |
Modifier and Type | Method | Description |
---|---|---|
<V1> MutableBag<V1> |
OrderedMapAdapter.countBy(Function<? super V,? extends V1> function) |
|
<V1,P> MutableBag<V1> |
OrderedMapAdapter.countByWith(Function2<? super V,? super P,? extends V1> function,
P parameter) |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<V> |
UnmodifiableTreeMap.toBag() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<V> |
SynchronizedBagMultimap.get(K key) |
|
MutableBag<V> |
SynchronizedBagMultimap.removeAll(java.lang.Object key) |
|
MutableBag<V> |
SynchronizedBagMultimap.replaceValues(K key,
java.lang.Iterable<? extends V> values) |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
PartitionHashBag.getRejected() |
|
MutableBag<T> |
PartitionHashBag.getSelected() |
Modifier and Type | Method | Description |
---|---|---|
MutableBag<T> |
ArrayStack.toBag() |
|
MutableBag<T> |
SynchronizedStack.toBag() |
|
MutableBag<T> |
UnmodifiableStack.toBag() |
Modifier and Type | Method | Description |
---|---|---|
static MutableBag<java.lang.Character> |
StringIterate.toBag(java.lang.String string) |
|
static MutableBag<java.lang.Character> |
StringIterate.toLowercaseBag(java.lang.String string) |
|
static MutableBag<java.lang.Character> |
StringIterate.toUppercaseBag(java.lang.String string) |
Copyright © 2004–2018. All rights reserved.