AbstractCollectionAdapter (Eclipse Collections

java.lang.Object
- org.eclipse.collections.impl.collection.mutable.AbstractCollectionAdapter<T>

All Implemented Interfaces:

Iterable<T>, Collection<T>, MutableCollection<T>, InternalIterable<T>, RichIterable<T>

Direct Known Subclasses:

AbstractListAdapter, CollectionAdapter, SetAdapter, SortedSetAdapter
```
public abstract class AbstractCollectionAdapter<T>
extends Object
implements MutableCollection<T>
```

Constructor Summary

Constructors
Constructor and Description

AbstractCollectionAdapter()

Constructors
Constructor and Description
`AbstractCollectionAdapter()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(T o)`
`boolean`	`addAll(Collection<? extends T> collection)`
`boolean`	`addAllIterable(Iterable<? extends T> iterable)`
`boolean`	`allSatisfy(Predicate<? super T> predicate)`
`<P> boolean`	`allSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`anySatisfy(Predicate<? super T> predicate)`
`<P> boolean`	`anySatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`
`void`	`appendString(Appendable appendable, String start, String separator, String end)`
`LazyIterable<T>`	`asLazy()`
`RichIterable<RichIterable<T>>`	`chunk(int size)`
`void`	`clear()`
`<V> MutableCollection<V>`	`collect(Function<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collect(Function<? super T,? extends V> function, R target)`
`<R extends MutableBooleanCollection> R`	`collectBoolean(BooleanFunction<? super T> booleanFunction, R target)`
`<R extends MutableByteCollection> R`	`collectByte(ByteFunction<? super T> byteFunction, R target)`
`<R extends MutableCharCollection> R`	`collectChar(CharFunction<? super T> charFunction, R target)`
`<R extends MutableDoubleCollection> R`	`collectDouble(DoubleFunction<? super T> doubleFunction, R target)`
`<R extends MutableFloatCollection> R`	`collectFloat(FloatFunction<? super T> floatFunction, R target)`
`<V> MutableCollection<V>`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)`
`<V,R extends Collection<V>> R`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function, R target)`
`<R extends MutableIntCollection> R`	`collectInt(IntFunction<? super T> intFunction, R target)`
`<R extends MutableLongCollection> R`	`collectLong(LongFunction<? super T> longFunction, R target)`
`<R extends MutableShortCollection> R`	`collectShort(ShortFunction<? super T> shortFunction, R target)`
`<P,A,R extends Collection<A>> R`	`collectWith(Function2<? super T,? super P,? extends A> function, P parameter, R targetCollection)`
`<P,V> MutableCollection<V>`	`collectWith(Function2<? super T,? super P,? extends V> function, P parameter)`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> collection)`
`boolean`	`containsAllArguments(Object... elements)`
`boolean`	`containsAllIterable(Iterable<?> source)`
`int`	`count(Predicate<? super T> predicate)`
`<P> int`	`countWith(Predicate2<? super T,? super P> predicate, P parameter)`
`T`	`detect(Predicate<? super T> predicate)`
`T`	`detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function)`
`Optional<T>`	`detectOptional(Predicate<? super T> predicate)`
`<P> T`	`detectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`<P> T`	`detectWithIfNone(Predicate2<? super T,? super P> predicate, P parameter, Function0<? extends T> function)`
`<P> Optional<T>`	`detectWithOptional(Predicate2<? super T,? super P> predicate, P parameter)`
`void`	`each(Procedure<? super T> procedure)`
`<V> MutableCollection<V>`	`flatCollect(Function<? super T,? extends Iterable<V>> function)`
`<V,R extends Collection<V>> R`	`flatCollect(Function<? super T,? extends Iterable<V>> function, R target)`
`<P> void`	`forEachWith(Procedure2<? super T,? super P> procedure, P parameter)`
`void`	`forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)`
`T`	`getFirst()`
`T`	`getLast()`
`T`	`getOnly()`
`<V> MutableMultimap<V,T>`	`groupBy(Function<? super T,? extends V> function)`
`<V,R extends MutableMultimap<V,T>> R`	`groupBy(Function<? super T,? extends V> function, R target)`
`<V> MutableMultimap<V,T>`	`groupByEach(Function<? super T,? extends Iterable<V>> function)`
`<V,R extends MutableMultimap<V,T>> R`	`groupByEach(Function<? super T,? extends Iterable<V>> function, R target)`
`<V> MutableMap<V,T>`	`groupByUniqueKey(Function<? super T,? extends V> function)`
`<V,R extends MutableMapIterable<V,T>> R`	`groupByUniqueKey(Function<? super T,? extends V> function, R target)`
`double`	`injectInto(double injectedValue, DoubleObjectToDoubleFunction<? super T> function)`
`float`	`injectInto(float injectedValue, FloatObjectToFloatFunction<? super T> function)`
`int`	`injectInto(int injectedValue, IntObjectToIntFunction<? super T> function)`
`<IV> IV`	`injectInto(IV injectedValue, Function2<? super IV,? super T,? extends IV> function)`
`long`	`injectInto(long injectedValue, LongObjectToLongFunction<? super T> function)`
`<IV,P> IV`	`injectIntoWith(IV injectValue, Function3<? super IV,? super T,? super P,? extends IV> function, P parameter)`
`<R extends Collection<T>> R`	`into(R target)`
`boolean`	`isEmpty()`
`Iterator<T>`	`iterator()`
`T`	`max()`
`T`	`max(Comparator<? super T> comparator)`
`<V extends Comparable<? super V>> T`	`maxBy(Function<? super T,? extends V> function)`
`T`	`min()`
`T`	`min(Comparator<? super T> comparator)`
`<V extends Comparable<? super V>> T`	`minBy(Function<? super T,? extends V> function)`
`boolean`	`noneSatisfy(Predicate<? super T> predicate)`
`<P> boolean`	`noneSatisfyWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`notEmpty()`
`PartitionMutableCollection<T>`	`partition(Predicate<? super T> predicate)`
`<P> PartitionMutableCollection<T>`	`partitionWith(Predicate2<? super T,? super P> predicate, P parameter)`
`MutableCollection<T>`	`reject(Predicate<? super T> predicate)`
`<R extends Collection<T>> R`	`reject(Predicate<? super T> predicate, R target)`
`<P> MutableCollection<T>`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`<P,R extends Collection<T>> R`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> collection)`
`boolean`	`removeAllIterable(Iterable<?> iterable)`
`boolean`	`removeIf(Predicate<? super T> predicate)`
`<P> boolean`	`removeIfWith(Predicate2<? super T,? super P> predicate, P parameter)`
`boolean`	`retainAll(Collection<?> collection)`
`boolean`	`retainAllIterable(Iterable<?> iterable)`
`MutableCollection<T>`	`select(Predicate<? super T> predicate)`
`<R extends Collection<T>> R`	`select(Predicate<? super T> predicate, R target)`
`<P> Twin<MutableList<T>>`	`selectAndRejectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`<S> MutableCollection<S>`	`selectInstancesOf(Class<S> clazz)`
`<P> MutableCollection<T>`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`<P,R extends Collection<T>> R`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter, R targetCollection)`
`int`	`size()`
`<V> MutableObjectDoubleMap<V>`	`sumByDouble(Function<? super T,? extends V> groupBy, DoubleFunction<? super T> function)`
`<V> MutableObjectDoubleMap<V>`	`sumByFloat(Function<? super T,? extends V> groupBy, FloatFunction<? super T> function)`
`<V> MutableObjectLongMap<V>`	`sumByInt(Function<? super T,? extends V> groupBy, IntFunction<? super T> function)`
`<V> MutableObjectLongMap<V>`	`sumByLong(Function<? super T,? extends V> groupBy, LongFunction<? super T> function)`
`double`	`sumOfDouble(DoubleFunction<? super T> function)`
`double`	`sumOfFloat(FloatFunction<? super T> function)`
`long`	`sumOfInt(IntFunction<? super T> function)`
`long`	`sumOfLong(LongFunction<? super T> function)`
`MutableCollection<T>`	`tap(Procedure<? super T> procedure)`
`Object[]`	`toArray()`
`<E> E[]`	`toArray(E[] a)`
`MutableBag<T>`	`toBag()`
`<K,V> MutableBiMap<K,V>`	`toBiMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`
`MutableList<T>`	`toList()`
`<K,V> MutableMap<K,V>`	`toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`
`<K,V,R extends Map<K,V>> R`	`toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction, R target)`
`MutableSet<T>`	`toSet()`
`MutableSortedBag<T>`	`toSortedBag()`
`MutableSortedBag<T>`	`toSortedBag(Comparator<? super T> comparator)`
`MutableList<T>`	`toSortedList(Comparator<? super T> comparator)`
`<K,V> MutableSortedMap<K,V>`	`toSortedMap(Comparator<? super K> comparator, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`
`<K,V> MutableSortedMap<K,V>`	`toSortedMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)`
`MutableSortedSet<T>`	`toSortedSet()`
`MutableSortedSet<T>`	`toSortedSet(Comparator<? super T> comparator)`
`String`	`toString()`
`<S> MutableCollection<Pair<T,S>>`	`zip(Iterable<S> that)`
`<S,R extends Collection<Pair<T,S>>> R`	`zip(Iterable<S> that, R target)`
`MutableCollection<Pair<T,Integer>>`	`zipWithIndex()`
`<R extends Collection<Pair<T,Integer>>> R`	`zipWithIndex(R target)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.collections.api.collection.MutableCollection
aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, countBy, countByEach, countByWith, flatCollectWith, newEmpty, toImmutable, with, withAll, without, withoutAll

Methods inherited from interface java.util.Collection
equals, hashCode, parallelStream, removeIf, spliterator, stream

Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, appendString, appendString, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, countBy, countByEach, countByWith, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, groupByAndCollect, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, makeString, makeString, makeString, makeString, maxByOptional, maxOptional, maxOptional, minByOptional, minOptional, minOptional, reduce, reduceInPlace, reduceInPlace, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, toImmutableBag, toImmutableBiMap, toImmutableList, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toSortedBagBy, toSortedList, toSortedListBy, toSortedMapBy, toSortedSetBy

Methods inherited from interface org.eclipse.collections.api.InternalIterable
forEach

Constructor Detail
- AbstractCollectionAdapter
```
public AbstractCollectionAdapter()
```

Method Detail

notEmpty
```
public boolean notEmpty()
```
Specified by:

notEmpty in interface RichIterable<T>

getFirst
```
public T getFirst()
```
Specified by:

getFirst in interface RichIterable<T>

getLast
```
public T getLast()
```
Specified by:

getLast in interface RichIterable<T>

getOnly
```
public T getOnly()
```
Specified by:

getOnly in interface RichIterable<T>

tap
```
public MutableCollection<T> tap(Procedure<? super T> procedure)
```
Specified by:

tap in interface MutableCollection<T>

Specified by:

tap in interface RichIterable<T>

each

public void each(Procedure<? super T> procedure)

Specified by:: each in interface RichIterable<T>

forEachWithIndex

public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)

Specified by:: forEachWithIndex in interface InternalIterable<T>

removeIf
```
public boolean removeIf(Predicate<? super T> predicate)
```
Specified by:

removeIf in interface MutableCollection<T>

removeIfWith

public <P> boolean removeIfWith(Predicate2<? super T,? super P> predicate,
                                P parameter)

Specified by:: removeIfWith in interface MutableCollection<T>

detect

public T detect(Predicate<? super T> predicate)

Specified by:: detect in interface RichIterable<T>

detectWith

public <P> T detectWith(Predicate2<? super T,? super P> predicate,
                        P parameter)

Specified by:: detectWith in interface RichIterable<T>

detectOptional

public Optional<T> detectOptional(Predicate<? super T> predicate)

Specified by:: detectOptional in interface RichIterable<T>

detectWithOptional

public <P> Optional<T> detectWithOptional(Predicate2<? super T,? super P> predicate,
                                          P parameter)

Specified by:: detectWithOptional in interface RichIterable<T>

detectIfNone

public T detectIfNone(Predicate<? super T> predicate,
                      Function0<? extends T> function)

Specified by:: detectIfNone in interface RichIterable<T>

detectWithIfNone

public <P> T detectWithIfNone(Predicate2<? super T,? super P> predicate,
                              P parameter,
                              Function0<? extends T> function)

Specified by:: detectWithIfNone in interface RichIterable<T>

min

public T min(Comparator<? super T> comparator)

Specified by:: min in interface RichIterable<T>

max

public T max(Comparator<? super T> comparator)

Specified by:: max in interface RichIterable<T>

min
```
public T min()
```
Specified by:

min in interface RichIterable<T>

max
```
public T max()
```
Specified by:

max in interface RichIterable<T>

minBy

public <V extends Comparable<? super V>> T minBy(Function<? super T,? extends V> function)

Specified by:: minBy in interface RichIterable<T>

maxBy

public <V extends Comparable<? super V>> T maxBy(Function<? super T,? extends V> function)

Specified by:: maxBy in interface RichIterable<T>

count

public int count(Predicate<? super T> predicate)

Specified by:: count in interface RichIterable<T>

anySatisfy

public boolean anySatisfy(Predicate<? super T> predicate)

Specified by:: anySatisfy in interface RichIterable<T>

allSatisfy

public boolean allSatisfy(Predicate<? super T> predicate)

Specified by:: allSatisfy in interface RichIterable<T>

noneSatisfy

public boolean noneSatisfy(Predicate<? super T> predicate)

Specified by:: noneSatisfy in interface RichIterable<T>

injectInto

public <IV> IV injectInto(IV injectedValue,
                          Function2<? super IV,? super T,? extends IV> function)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public int injectInto(int injectedValue,
                      IntObjectToIntFunction<? super T> function)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public long injectInto(long injectedValue,
                       LongObjectToLongFunction<? super T> function)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public double injectInto(double injectedValue,
                         DoubleObjectToDoubleFunction<? super T> function)

Specified by:: injectInto in interface RichIterable<T>

injectInto

public float injectInto(float injectedValue,
                        FloatObjectToFloatFunction<? super T> function)

Specified by:: injectInto in interface RichIterable<T>

sumOfInt

public long sumOfInt(IntFunction<? super T> function)

Specified by:: sumOfInt in interface RichIterable<T>

sumOfFloat

public double sumOfFloat(FloatFunction<? super T> function)

Specified by:: sumOfFloat in interface RichIterable<T>

sumOfLong

public long sumOfLong(LongFunction<? super T> function)

Specified by:: sumOfLong in interface RichIterable<T>

sumOfDouble

public double sumOfDouble(DoubleFunction<? super T> function)

Specified by:: sumOfDouble in interface RichIterable<T>

sumByInt

public <V> MutableObjectLongMap<V> sumByInt(Function<? super T,? extends V> groupBy,
                                            IntFunction<? super T> function)

Specified by:: sumByInt in interface MutableCollection<T>
Specified by:: sumByInt in interface RichIterable<T>

sumByFloat

public <V> MutableObjectDoubleMap<V> sumByFloat(Function<? super T,? extends V> groupBy,
                                                FloatFunction<? super T> function)

Specified by:: sumByFloat in interface MutableCollection<T>
Specified by:: sumByFloat in interface RichIterable<T>

sumByLong

public <V> MutableObjectLongMap<V> sumByLong(Function<? super T,? extends V> groupBy,
                                             LongFunction<? super T> function)

Specified by:: sumByLong in interface MutableCollection<T>
Specified by:: sumByLong in interface RichIterable<T>

sumByDouble

public <V> MutableObjectDoubleMap<V> sumByDouble(Function<? super T,? extends V> groupBy,
                                                 DoubleFunction<? super T> function)

Specified by:: sumByDouble in interface MutableCollection<T>
Specified by:: sumByDouble in interface RichIterable<T>

select
```
public MutableCollection<T> select(Predicate<? super T> predicate)
```
Specified by:

select in interface MutableCollection<T>

Specified by:

select in interface RichIterable<T>

select

public <R extends Collection<T>> R select(Predicate<? super T> predicate,
                                          R target)

Specified by:: select in interface RichIterable<T>

reject
```
public MutableCollection<T> reject(Predicate<? super T> predicate)
```
Specified by:

reject in interface MutableCollection<T>

Specified by:

reject in interface RichIterable<T>

reject

public <R extends Collection<T>> R reject(Predicate<? super T> predicate,
                                          R target)

Specified by:: reject in interface RichIterable<T>

selectInstancesOf
```
public <S> MutableCollection<S> selectInstancesOf(Class<S> clazz)
```
Specified by:

selectInstancesOf in interface MutableCollection<T>

Specified by:

selectInstancesOf in interface RichIterable<T>

collect
```
public <V> MutableCollection<V> collect(Function<? super T,? extends V> function)
```
Specified by:

collect in interface MutableCollection<T>

Specified by:

collect in interface RichIterable<T>

collectBoolean

public <R extends MutableBooleanCollection> R collectBoolean(BooleanFunction<? super T> booleanFunction,
                                                             R target)

Specified by:: collectBoolean in interface RichIterable<T>

collectByte

public <R extends MutableByteCollection> R collectByte(ByteFunction<? super T> byteFunction,
                                                       R target)

Specified by:: collectByte in interface RichIterable<T>

collectChar

public <R extends MutableCharCollection> R collectChar(CharFunction<? super T> charFunction,
                                                       R target)

Specified by:: collectChar in interface RichIterable<T>

collectDouble

public <R extends MutableDoubleCollection> R collectDouble(DoubleFunction<? super T> doubleFunction,
                                                           R target)

Specified by:: collectDouble in interface RichIterable<T>

collectFloat

public <R extends MutableFloatCollection> R collectFloat(FloatFunction<? super T> floatFunction,
                                                         R target)

Specified by:: collectFloat in interface RichIterable<T>

collectInt

public <R extends MutableIntCollection> R collectInt(IntFunction<? super T> intFunction,
                                                     R target)

Specified by:: collectInt in interface RichIterable<T>

collectLong

public <R extends MutableLongCollection> R collectLong(LongFunction<? super T> longFunction,
                                                       R target)

Specified by:: collectLong in interface RichIterable<T>

collectShort

public <R extends MutableShortCollection> R collectShort(ShortFunction<? super T> shortFunction,
                                                         R target)

Specified by:: collectShort in interface RichIterable<T>

collect

public <V,R extends Collection<V>> R collect(Function<? super T,? extends V> function,
                                             R target)

Specified by:: collect in interface RichIterable<T>

flatCollect
```
public <V> MutableCollection<V> flatCollect(Function<? super T,? extends Iterable<V>> function)
```
Specified by:

flatCollect in interface MutableCollection<T>

Specified by:

flatCollect in interface RichIterable<T>

flatCollect

public <V,R extends Collection<V>> R flatCollect(Function<? super T,? extends Iterable<V>> function,
                                                 R target)

Specified by:: flatCollect in interface RichIterable<T>

collectIf

public <V> MutableCollection<V> collectIf(Predicate<? super T> predicate,
                                          Function<? super T,? extends V> function)

Specified by:: collectIf in interface MutableCollection<T>
Specified by:: collectIf in interface RichIterable<T>

collectIf

public <V,R extends Collection<V>> R collectIf(Predicate<? super T> predicate,
                                               Function<? super T,? extends V> function,
                                               R target)

Specified by:: collectIf in interface RichIterable<T>

selectAndRejectWith

public <P> Twin<MutableList<T>> selectAndRejectWith(Predicate2<? super T,? super P> predicate,
                                                    P parameter)

Specified by:: selectAndRejectWith in interface MutableCollection<T>

partition
```
public PartitionMutableCollection<T> partition(Predicate<? super T> predicate)
```
Specified by:

partition in interface MutableCollection<T>

Specified by:

partition in interface RichIterable<T>

partitionWith

public <P> PartitionMutableCollection<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                                       P parameter)

Specified by:: partitionWith in interface MutableCollection<T>
Specified by:: partitionWith in interface RichIterable<T>

size
```
public int size()
```
Specified by:

size in interface Collection<T>

Specified by:

size in interface RichIterable<T>

isEmpty
```
public boolean isEmpty()
```
Specified by:

isEmpty in interface Collection<T>

Specified by:

isEmpty in interface RichIterable<T>

contains
```
public boolean contains(Object o)
```
Specified by:

contains in interface Collection<T>

Specified by:

contains in interface RichIterable<T>

iterator
```
public Iterator<T> iterator()
```
Specified by:

iterator in interface Iterable<T>

Specified by:

iterator in interface Collection<T>

toArray
```
public Object[] toArray()
```
Specified by:

toArray in interface Collection<T>

Specified by:

toArray in interface RichIterable<T>

toArray
```
public <E> E[] toArray(E[] a)
```
Specified by:

toArray in interface Collection<T>

Specified by:

toArray in interface RichIterable<T>

add
```
public boolean add(T o)
```
Specified by:

add in interface Collection<T>

remove
```
public boolean remove(Object o)
```
Specified by:

remove in interface Collection<T>

containsAll
```
public boolean containsAll(Collection<?> collection)
```
Specified by:

containsAll in interface Collection<T>

Specified by:

containsAll in interface RichIterable<T>

containsAllIterable
```
public boolean containsAllIterable(Iterable<?> source)
```
Specified by:

containsAllIterable in interface RichIterable<T>

containsAllArguments
```
public boolean containsAllArguments(Object... elements)
```
Specified by:

containsAllArguments in interface RichIterable<T>

addAll

public boolean addAll(Collection<? extends T> collection)

Specified by:: addAll in interface Collection<T>

addAllIterable
```
public boolean addAllIterable(Iterable<? extends T> iterable)
```
Specified by:

addAllIterable in interface MutableCollection<T>

removeAll
```
public boolean removeAll(Collection<?> collection)
```
Specified by:

removeAll in interface Collection<T>

removeAllIterable
```
public boolean removeAllIterable(Iterable<?> iterable)
```
Specified by:

removeAllIterable in interface MutableCollection<T>

retainAll
```
public boolean retainAll(Collection<?> collection)
```
Specified by:

retainAll in interface Collection<T>

retainAllIterable
```
public boolean retainAllIterable(Iterable<?> iterable)
```
Specified by:

retainAllIterable in interface MutableCollection<T>

clear
```
public void clear()
```
Specified by:

clear in interface Collection<T>

forEachWith

public <P> void forEachWith(Procedure2<? super T,? super P> procedure,
                            P parameter)

Specified by:: forEachWith in interface InternalIterable<T>

selectWith

public <P> MutableCollection<T> selectWith(Predicate2<? super T,? super P> predicate,
                                           P parameter)

Specified by:: selectWith in interface MutableCollection<T>
Specified by:: selectWith in interface RichIterable<T>

selectWith

public <P,R extends Collection<T>> R selectWith(Predicate2<? super T,? super P> predicate,
                                                P parameter,
                                                R targetCollection)

Specified by:: selectWith in interface RichIterable<T>

rejectWith

public <P> MutableCollection<T> rejectWith(Predicate2<? super T,? super P> predicate,
                                           P parameter)

Specified by:: rejectWith in interface MutableCollection<T>
Specified by:: rejectWith in interface RichIterable<T>

rejectWith

public <P,R extends Collection<T>> R rejectWith(Predicate2<? super T,? super P> predicate,
                                                P parameter,
                                                R targetCollection)

Specified by:: rejectWith in interface RichIterable<T>

collectWith

public <P,V> MutableCollection<V> collectWith(Function2<? super T,? super P,? extends V> function,
                                              P parameter)

Specified by:: collectWith in interface MutableCollection<T>
Specified by:: collectWith in interface RichIterable<T>

collectWith

public <P,A,R extends Collection<A>> R collectWith(Function2<? super T,? super P,? extends A> function,
                                                   P parameter,
                                                   R targetCollection)

Specified by:: collectWith in interface RichIterable<T>

injectIntoWith

public <IV,P> IV injectIntoWith(IV injectValue,
                                Function3<? super IV,? super T,? super P,? extends IV> function,
                                P parameter)

Specified by:: injectIntoWith in interface MutableCollection<T>

into

public <R extends Collection<T>> R into(R target)

Specified by:: into in interface RichIterable<T>

toList
```
public MutableList<T> toList()
```
Specified by:

toList in interface RichIterable<T>

toSortedList

public MutableList<T> toSortedList(Comparator<? super T> comparator)

Specified by:: toSortedList in interface RichIterable<T>

toSortedSet
```
public MutableSortedSet<T> toSortedSet()
```
Specified by:

toSortedSet in interface RichIterable<T>

toSortedSet

public MutableSortedSet<T> toSortedSet(Comparator<? super T> comparator)

Specified by:: toSortedSet in interface RichIterable<T>

toSet
```
public MutableSet<T> toSet()
```
Specified by:

toSet in interface RichIterable<T>

toBag
```
public MutableBag<T> toBag()
```
Specified by:

toBag in interface RichIterable<T>

toSortedBag
```
public MutableSortedBag<T> toSortedBag()
```
Specified by:

toSortedBag in interface RichIterable<T>

toSortedBag

public MutableSortedBag<T> toSortedBag(Comparator<? super T> comparator)

Specified by:: toSortedBag in interface RichIterable<T>

toMap

public <K,V> MutableMap<K,V> toMap(Function<? super T,? extends K> keyFunction,
                                   Function<? super T,? extends V> valueFunction)

Specified by:: toMap in interface RichIterable<T>

toMap

public <K,V,R extends Map<K,V>> R toMap(Function<? super T,? extends K> keyFunction,
                                        Function<? super T,? extends V> valueFunction,
                                        R target)

Specified by:: toMap in interface RichIterable<T>

toSortedMap

public <K,V> MutableSortedMap<K,V> toSortedMap(Function<? super T,? extends K> keyFunction,
                                               Function<? super T,? extends V> valueFunction)

Specified by:: toSortedMap in interface RichIterable<T>

toSortedMap

public <K,V> MutableSortedMap<K,V> toSortedMap(Comparator<? super K> comparator,
                                               Function<? super T,? extends K> keyFunction,
                                               Function<? super T,? extends V> valueFunction)

Specified by:: toSortedMap in interface RichIterable<T>

toBiMap

public <K,V> MutableBiMap<K,V> toBiMap(Function<? super T,? extends K> keyFunction,
                                       Function<? super T,? extends V> valueFunction)

Specified by:: toBiMap in interface RichIterable<T>

asLazy
```
public LazyIterable<T> asLazy()
```
Specified by:

asLazy in interface RichIterable<T>

countWith

public <P> int countWith(Predicate2<? super T,? super P> predicate,
                         P parameter)

Specified by:: countWith in interface RichIterable<T>

anySatisfyWith

public <P> boolean anySatisfyWith(Predicate2<? super T,? super P> predicate,
                                  P parameter)

Specified by:: anySatisfyWith in interface RichIterable<T>

allSatisfyWith

public <P> boolean allSatisfyWith(Predicate2<? super T,? super P> predicate,
                                  P parameter)

Specified by:: allSatisfyWith in interface RichIterable<T>

noneSatisfyWith

public <P> boolean noneSatisfyWith(Predicate2<? super T,? super P> predicate,
                                   P parameter)

Specified by:: noneSatisfyWith in interface RichIterable<T>

toString
```
public String toString()
```
Specified by:

toString in interface RichIterable<T>

Overrides:

toString in class Object

appendString

public void appendString(Appendable appendable,
                         String start,
                         String separator,
                         String end)

Specified by:: appendString in interface RichIterable<T>

groupBy
```
public <V> MutableMultimap<V,T> groupBy(Function<? super T,? extends V> function)
```
Specified by:

groupBy in interface MutableCollection<T>

Specified by:

groupBy in interface RichIterable<T>

groupBy

public <V,R extends MutableMultimap<V,T>> R groupBy(Function<? super T,? extends V> function,
                                                    R target)

Specified by:: groupBy in interface RichIterable<T>

groupByEach
```
public <V> MutableMultimap<V,T> groupByEach(Function<? super T,? extends Iterable<V>> function)
```
Specified by:

groupByEach in interface MutableCollection<T>

Specified by:

groupByEach in interface RichIterable<T>

groupByEach

public <V,R extends MutableMultimap<V,T>> R groupByEach(Function<? super T,? extends Iterable<V>> function,
                                                        R target)

Specified by:: groupByEach in interface RichIterable<T>

groupByUniqueKey
```
public <V> MutableMap<V,T> groupByUniqueKey(Function<? super T,? extends V> function)
```
Specified by:

groupByUniqueKey in interface MutableCollection<T>

Specified by:

groupByUniqueKey in interface RichIterable<T>

groupByUniqueKey

public <V,R extends MutableMapIterable<V,T>> R groupByUniqueKey(Function<? super T,? extends V> function,
                                                                R target)

Specified by:: groupByUniqueKey in interface RichIterable<T>

zip
```
public <S> MutableCollection<Pair<T,S>> zip(Iterable<S> that)
```
Specified by:

zip in interface MutableCollection<T>

Specified by:

zip in interface RichIterable<T>

zip

public <S,R extends Collection<Pair<T,S>>> R zip(Iterable<S> that,
                                                 R target)

Specified by:: zip in interface RichIterable<T>

zipWithIndex
```
public MutableCollection<Pair<T,Integer>> zipWithIndex()
```
Specified by:

zipWithIndex in interface MutableCollection<T>

Specified by:

zipWithIndex in interface RichIterable<T>

zipWithIndex

public <R extends Collection<Pair<T,Integer>>> R zipWithIndex(R target)

Specified by:: zipWithIndex in interface RichIterable<T>

chunk

public RichIterable<RichIterable<T>> chunk(int size)

Specified by:: chunk in interface RichIterable<T>

Class AbstractCollectionAdapter<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.collection.MutableCollection

Methods inherited from interface java.util.Collection

Methods inherited from interface org.eclipse.collections.api.RichIterable

Methods inherited from interface org.eclipse.collections.api.InternalIterable

Constructor Detail

AbstractCollectionAdapter

Method Detail

notEmpty

getFirst

getLast

getOnly

tap

each

forEachWithIndex

removeIf

removeIfWith

detect

detectWith

detectOptional

detectWithOptional

detectIfNone

detectWithIfNone

min

max

min

max

minBy

maxBy

count

anySatisfy

allSatisfy

noneSatisfy

injectInto

injectInto

injectInto

injectInto

injectInto

sumOfInt

sumOfFloat

sumOfLong

sumOfDouble

sumByInt

sumByFloat

sumByLong

sumByDouble

select

select

reject

reject

selectInstancesOf

collect

collectBoolean

collectByte

collectChar

collectDouble

collectFloat

collectInt

collectLong

collectShort

collect

flatCollect

flatCollect

collectIf

collectIf

selectAndRejectWith

partition

partitionWith

size

isEmpty

contains

iterator

toArray

toArray

add

remove

containsAll