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

All Implemented Interfaces:

Serializable, Cloneable, Iterable<T>, Collection<T>, List<T>, RandomAccess, MutableCollection<T>, InternalIterable<T>, ListIterable<T>, MutableList<T>, OrderedIterable<T>, ReversibleIterable<T>, RichIterable<T>
```
public final class RandomAccessListAdapter<T>
extends AbstractListAdapter<T>
implements RandomAccess, Serializable
```
This class provides a MutableList wrapper around a JDK Collections List interface instance. All the MutableList interface methods are supported in addition to the JDK List interface methods.
To create a new wrapper around an existing List instance, use the adapt(List) factory method.

See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static <E> MutableList<E>`	`adapt(List<E> list)`
`boolean`	`allSatisfy(Predicate<? super T> predicate)`
`boolean`	`anySatisfy(Predicate<? super T> predicate)`
`MutableList<T>`	`asSynchronized()`
`MutableList<T>`	`asUnmodifiable()`
`MutableList<T>`	`clone()`
`<V> MutableList<V>`	`collect(Function<? super T,? extends V> function)`
`<V> MutableList<V>`	`collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)`
`<P,V> MutableList<V>`	`collectWith(Function2<? super T,? super P,? extends V> function, P parameter)`
`<S> boolean`	`corresponds(OrderedIterable<S> other, Predicate2<? super T,? super S> predicate)`
`int`	`count(Predicate<? super T> predicate)`
`T`	`detect(Predicate<? super T> predicate)`
`T`	`detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function)`
`int`	`detectIndex(Predicate<? super T> predicate)`
`int`	`detectLastIndex(Predicate<? super T> predicate)`
`MutableList<T>`	`distinct()`
`MutableList<T>`	`distinct(HashingStrategy<? super T> hashingStrategy)`
`MutableList<T>`	`drop(int count)`
`MutableList<T>`	`dropWhile(Predicate<? super T> predicate)`
`void`	`each(Procedure<? super T> procedure)`
`<V> MutableList<V>`	`flatCollect(Function<? super T,? extends Iterable<V>> function)`
`void`	`forEach(int fromIndex, int toIndex, Procedure<? super T> procedure)`
`void`	`forEachWithIndex(int fromIndex, int toIndex, ObjectIntProcedure<? super T> objectIntProcedure)`
`void`	`forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)`
`<V> FastListMultimap<V,T>`	`groupBy(Function<? super T,? extends V> function)`
`<V> FastListMultimap<V,T>`	`groupByEach(Function<? super T,? extends Iterable<V>> function)`
`<IV> IV`	`injectInto(IV injectedValue, Function2<? super IV,? super T,? extends IV> function)`
`MutableList<T>`	`newEmpty()`	Deprecated. use `FastList.newList()` instead (inlineable)
`boolean`	`noneSatisfy(Predicate<? super T> predicate)`
`PartitionMutableList<T>`	`partition(Predicate<? super T> predicate)`
`PartitionMutableList<T>`	`partitionWhile(Predicate<? super T> predicate)`
`<P> PartitionMutableList<T>`	`partitionWith(Predicate2<? super T,? super P> predicate, P parameter)`
`MutableList<T>`	`reject(Predicate<? super T> predicate)`
`<P> MutableList<T>`	`rejectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`void`	`reverseForEach(Procedure<? super T> procedure)`
`void`	`reverseForEachWithIndex(ObjectIntProcedure<? super T> procedure)`
`MutableList<T>`	`select(Predicate<? super T> predicate)`
`<S> MutableList<S>`	`selectInstancesOf(Class<S> clazz)`
`<P> MutableList<T>`	`selectWith(Predicate2<? super T,? super P> predicate, P parameter)`
`void`	`sort(Comparator<? super T> comparator)`
`RandomAccessListAdapter<T>`	`sortThis()`
`RandomAccessListAdapter<T>`	`sortThis(Comparator<? super T> comparator)`
`MutableList<T>`	`take(int count)`
`MutableList<T>`	`takeWhile(Predicate<? super T> predicate)`
`ImmutableList<T>`	`toImmutable()`
`RandomAccessListAdapter<T>`	`with(T element)`
`RandomAccessListAdapter<T>`	`with(T... elements)`
`RandomAccessListAdapter<T>`	`with(T element1, T element2)`
`RandomAccessListAdapter<T>`	`with(T element1, T element2, T element3)`
`RandomAccessListAdapter<T>`	`withAll(Iterable<? extends T> elements)`
`RandomAccessListAdapter<T>`	`without(T element)`
`RandomAccessListAdapter<T>`	`withoutAll(Iterable<? extends T> elements)`
`<S> MutableList<Pair<T,S>>`	`zip(Iterable<S> that)`
`MutableList<Pair<T,Integer>>`	`zipWithIndex()`

Methods inherited from class org.eclipse.collections.impl.list.mutable.AbstractListAdapter
add, addAll, asParallel, asReversed, distinctBy, equals, get, hashCode, indexOf, lastIndexOf, listIterator, listIterator, remove, set, sortThisByBoolean, sortThisByByte, sortThisByChar, sortThisByDouble, sortThisByFloat, sortThisByInt, sortThisByLong, sortThisByShort, subList, tap, toStack

Methods inherited from class org.eclipse.collections.impl.collection.mutable.AbstractCollectionAdapter
add, addAll, addAllIterable, allSatisfyWith, anySatisfyWith, appendString, asLazy, chunk, clear, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, countWith, detectOptional, detectWith, detectWithIfNone, detectWithOptional, flatCollect, forEachWith, getFirst, getLast, getOnly, groupBy, groupByEach, groupByUniqueKey, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectIntoWith, into, isEmpty, iterator, max, max, maxBy, min, min, minBy, noneSatisfyWith, notEmpty, reject, rejectWith, remove, removeAll, removeAllIterable, removeIf, removeIfWith, retainAll, retainAllIterable, select, selectAndRejectWith, selectWith, size, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedList, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toString, zip, zipWithIndex

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

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream, toArray

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

Methods inherited from interface java.util.List
add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, replaceAll, retainAll, size, spliterator, toArray, toArray

Methods inherited from interface org.eclipse.collections.api.list.ListIterable
binarySearch, binarySearch, forEachInBoth

Methods inherited from interface org.eclipse.collections.api.collection.MutableCollection
addAllIterable, aggregateBy, aggregateInPlaceBy, countBy, countByEach, countByWith, groupByUniqueKey, injectIntoWith, removeAllIterable, removeIf, removeIfWith, retainAllIterable, selectAndRejectWith, sumByDouble, sumByFloat, sumByInt, sumByLong

Methods inherited from interface org.eclipse.collections.api.list.MutableList
collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, collectWithIndex, flatCollectWith, getFirst, getLast, rejectWithIndex, reverseThis, selectWithIndex, shuffleThis, shuffleThis, sortThisBy, toImmutableList, toReversed

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable
collectWithIndex, getFirstOptional, getLastOptional, max, min, rejectWithIndex, selectWithIndex, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.RichIterable
aggregateBy, allSatisfyWith, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsAny, containsAnyIterable, containsBy, containsNone, containsNoneIterable, countBy, countByEach, countByWith, countWith, detectOptional, detectWith, detectWithIfNone, detectWithOptional, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, getOnly, groupBy, groupByAndCollect, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, into, isEmpty, makeString, makeString, makeString, makeString, max, maxBy, maxByOptional, maxOptional, maxOptional, min, minBy, minByOptional, minOptional, minOptional, noneSatisfyWith, notEmpty, reduce, reduceInPlace, reduceInPlace, reject, rejectWith, select, selectWith, size, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toImmutableBag, toImmutableBiMap, toImmutableMap, toImmutableSet, toImmutableSortedBag, toImmutableSortedBag, toImmutableSortedBagBy, toImmutableSortedList, toImmutableSortedList, toImmutableSortedListBy, toImmutableSortedSet, toImmutableSortedSet, toImmutableSortedSetBy, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toString

- Method Detail
  - adapt
```
public static <E> MutableList<E> adapt(List<E> list)
```
  - toImmutable
```
public ImmutableList<T> toImmutable()
```
    Specified by:
    
    toImmutable in interface ListIterable<T>
    
    Specified by:
    
    toImmutable in interface MutableCollection<T>
    
    Specified by:
    
    toImmutable in interface MutableList<T>
  - asUnmodifiable
```
public MutableList<T> asUnmodifiable()
```
    Specified by:
    
    asUnmodifiable in interface MutableCollection<T>
    
    Specified by:
    
    asUnmodifiable in interface MutableList<T>
  - asSynchronized
```
public MutableList<T> asSynchronized()
```
    Specified by:
    
    asSynchronized in interface MutableCollection<T>
    
    Specified by:
    
    asSynchronized in interface MutableList<T>
  - clone
```
public MutableList<T> clone()
```
    Specified by:
    
    clone in interface MutableList<T>
    
    Overrides:
    
    clone in class AbstractListAdapter<T>
  - newEmpty
```
@Deprecated
public MutableList<T> newEmpty()
```
    Deprecated.
    use FastList.newList() instead (inlineable)
    
    Specified by:
    
    newEmpty in interface MutableCollection<T>
    
    Specified by:
    
    newEmpty in interface MutableList<T>
  - each
```
public void each(Procedure<? super T> procedure)
```
    Specified by:
    
    each in interface RichIterable<T>
    
    Overrides:
    
    each in class AbstractCollectionAdapter<T>
  - reverseForEach
```
public void reverseForEach(Procedure<? super T> procedure)
```
    Specified by:
    
    reverseForEach in interface ReversibleIterable<T>
  - reverseForEachWithIndex
```
public void reverseForEachWithIndex(ObjectIntProcedure<? super T> procedure)
```
    Specified by:
    
    reverseForEachWithIndex in interface ReversibleIterable<T>
  - forEachWithIndex
```
public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)
```
    Specified by:
    
    forEachWithIndex in interface InternalIterable<T>
    
    Specified by:
    
    forEachWithIndex in interface OrderedIterable<T>
    
    Overrides:
    
    forEachWithIndex in class AbstractCollectionAdapter<T>
  - forEachWithIndex
```
public void forEachWithIndex(int fromIndex,
                             int toIndex,
                             ObjectIntProcedure<? super T> objectIntProcedure)
```
    Specified by:
    
    forEachWithIndex in interface OrderedIterable<T>
  - detect
```
public T detect(Predicate<? super T> predicate)
```
    Specified by:
    
    detect in interface RichIterable<T>
    
    Overrides:
    
    detect in class AbstractCollectionAdapter<T>
  - detectIfNone
```
public T detectIfNone(Predicate<? super T> predicate,
                      Function0<? extends T> function)
```
    Specified by:
    
    detectIfNone in interface RichIterable<T>
    
    Overrides:
    
    detectIfNone in class AbstractCollectionAdapter<T>
  - detectIndex
```
public int detectIndex(Predicate<? super T> predicate)
```
    Specified by:
    
    detectIndex in interface OrderedIterable<T>
  - detectLastIndex
```
public int detectLastIndex(Predicate<? super T> predicate)
```
    Specified by:
    
    detectLastIndex in interface ReversibleIterable<T>
  - count
```
public int count(Predicate<? super T> predicate)
```
    Specified by:
    
    count in interface RichIterable<T>
    
    Overrides:
    
    count in class AbstractCollectionAdapter<T>
  - corresponds
```
public <S> boolean corresponds(OrderedIterable<S> other,
                               Predicate2<? super T,? super S> predicate)
```
    Specified by:
    
    corresponds in interface OrderedIterable<T>
  - anySatisfy
```
public boolean anySatisfy(Predicate<? super T> predicate)
```
    Specified by:
    
    anySatisfy in interface RichIterable<T>
    
    Overrides:
    
    anySatisfy in class AbstractCollectionAdapter<T>
  - allSatisfy
```
public boolean allSatisfy(Predicate<? super T> predicate)
```
    Specified by:
    
    allSatisfy in interface RichIterable<T>
    
    Overrides:
    
    allSatisfy in class AbstractCollectionAdapter<T>
  - noneSatisfy
```
public boolean noneSatisfy(Predicate<? super T> predicate)
```
    Specified by:
    
    noneSatisfy in interface RichIterable<T>
    
    Overrides:
    
    noneSatisfy in class AbstractCollectionAdapter<T>
  - injectInto
```
public <IV> IV injectInto(IV injectedValue,
                          Function2<? super IV,? super T,? extends IV> function)
```
    Specified by:
    
    injectInto in interface RichIterable<T>
    
    Overrides:
    
    injectInto in class AbstractCollectionAdapter<T>
  - forEach
```
public void forEach(int fromIndex,
                    int toIndex,
                    Procedure<? super T> procedure)
```
    Specified by:
    
    forEach in interface OrderedIterable<T>
  - sort
```
public void sort(Comparator<? super T> comparator)
```
    Specified by:
    
    sort in interface List<T>
  - sortThis
```
public RandomAccessListAdapter<T> sortThis(Comparator<? super T> comparator)
```
    Specified by:
    
    sortThis in interface MutableList<T>
  - sortThis
```
public RandomAccessListAdapter<T> sortThis()
```
    Specified by:
    
    sortThis in interface MutableList<T>
  - with
```
public RandomAccessListAdapter<T> with(T element)
```
    Specified by:
    
    with in interface MutableCollection<T>
    
    Specified by:
    
    with in interface MutableList<T>
  - with
```
public RandomAccessListAdapter<T> with(T element1,
                                       T element2)
```
  - with
```
public RandomAccessListAdapter<T> with(T element1,
                                       T element2,
                                       T element3)
```
  - with
```
public RandomAccessListAdapter<T> with(T... elements)
```
  - without
```
public RandomAccessListAdapter<T> without(T element)
```
    Specified by:
    
    without in interface MutableCollection<T>
    
    Specified by:
    
    without in interface MutableList<T>
  - withAll
```
public RandomAccessListAdapter<T> withAll(Iterable<? extends T> elements)
```
    Specified by:
    
    withAll in interface MutableCollection<T>
    
    Specified by:
    
    withAll in interface MutableList<T>
  - withoutAll
```
public RandomAccessListAdapter<T> withoutAll(Iterable<? extends T> elements)
```
    Specified by:
    
    withoutAll in interface MutableCollection<T>
    
    Specified by:
    
    withoutAll in interface MutableList<T>
  - select
```
public MutableList<T> select(Predicate<? super T> predicate)
```
    Specified by:
    
    select in interface ListIterable<T>
    
    Specified by:
    
    select in interface MutableCollection<T>
    
    Specified by:
    
    select in interface MutableList<T>
    
    Specified by:
    
    select in interface OrderedIterable<T>
    
    Specified by:
    
    select in interface ReversibleIterable<T>
    
    Specified by:
    
    select in interface RichIterable<T>
    
    Overrides:
    
    select in class AbstractListAdapter<T>
  - reject
```
public MutableList<T> reject(Predicate<? super T> predicate)
```
    Specified by:
    
    reject in interface ListIterable<T>
    
    Specified by:
    
    reject in interface MutableCollection<T>
    
    Specified by:
    
    reject in interface MutableList<T>
    
    Specified by:
    
    reject in interface OrderedIterable<T>
    
    Specified by:
    
    reject in interface ReversibleIterable<T>
    
    Specified by:
    
    reject in interface RichIterable<T>
    
    Overrides:
    
    reject in class AbstractListAdapter<T>
  - partition
```
public PartitionMutableList<T> partition(Predicate<? super T> predicate)
```
    Specified by:
    
    partition in interface ListIterable<T>
    
    Specified by:
    
    partition in interface MutableCollection<T>
    
    Specified by:
    
    partition in interface MutableList<T>
    
    Specified by:
    
    partition in interface OrderedIterable<T>
    
    Specified by:
    
    partition in interface ReversibleIterable<T>
    
    Specified by:
    
    partition in interface RichIterable<T>
    
    Overrides:
    
    partition in class AbstractListAdapter<T>
  - partitionWith
```
public <P> PartitionMutableList<T> partitionWith(Predicate2<? super T,? super P> predicate,
                                                 P parameter)
```
    Specified by:
    
    partitionWith in interface ListIterable<T>
    
    Specified by:
    
    partitionWith in interface MutableCollection<T>
    
    Specified by:
    
    partitionWith in interface MutableList<T>
    
    Specified by:
    
    partitionWith in interface OrderedIterable<T>
    
    Specified by:
    
    partitionWith in interface ReversibleIterable<T>
    
    Specified by:
    
    partitionWith in interface RichIterable<T>
    
    Overrides:
    
    partitionWith in class AbstractListAdapter<T>
  - selectInstancesOf
```
public <S> MutableList<S> selectInstancesOf(Class<S> clazz)
```
    Specified by:
    
    selectInstancesOf in interface ListIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableCollection<T>
    
    Specified by:
    
    selectInstancesOf in interface MutableList<T>
    
    Specified by:
    
    selectInstancesOf in interface OrderedIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface ReversibleIterable<T>
    
    Specified by:
    
    selectInstancesOf in interface RichIterable<T>
    
    Overrides:
    
    selectInstancesOf in class AbstractListAdapter<T>
  - collect
```
public <V> MutableList<V> collect(Function<? super T,? extends V> function)
```
    Specified by:
    
    collect in interface ListIterable<T>
    
    Specified by:
    
    collect in interface MutableCollection<T>
    
    Specified by:
    
    collect in interface MutableList<T>
    
    Specified by:
    
    collect in interface OrderedIterable<T>
    
    Specified by:
    
    collect in interface ReversibleIterable<T>
    
    Specified by:
    
    collect in interface RichIterable<T>
    
    Overrides:
    
    collect in class AbstractListAdapter<T>
  - flatCollect
```
public <V> MutableList<V> flatCollect(Function<? super T,? extends Iterable<V>> function)
```
    Specified by:
    
    flatCollect in interface ListIterable<T>
    
    Specified by:
    
    flatCollect in interface MutableCollection<T>
    
    Specified by:
    
    flatCollect in interface MutableList<T>
    
    Specified by:
    
    flatCollect in interface OrderedIterable<T>
    
    Specified by:
    
    flatCollect in interface ReversibleIterable<T>
    
    Specified by:
    
    flatCollect in interface RichIterable<T>
    
    Overrides:
    
    flatCollect in class AbstractListAdapter<T>
  - collectIf
```
public <V> MutableList<V> collectIf(Predicate<? super T> predicate,
                                    Function<? super T,? extends V> function)
```
    Specified by:
    
    collectIf in interface ListIterable<T>
    
    Specified by:
    
    collectIf in interface MutableCollection<T>
    
    Specified by:
    
    collectIf in interface MutableList<T>
    
    Specified by:
    
    collectIf in interface OrderedIterable<T>
    
    Specified by:
    
    collectIf in interface ReversibleIterable<T>
    
    Specified by:
    
    collectIf in interface RichIterable<T>
    
    Overrides:
    
    collectIf in class AbstractListAdapter<T>
  - groupBy
```
public <V> FastListMultimap<V,T> groupBy(Function<? super T,? extends V> function)
```
    Specified by:
    
    groupBy in interface ListIterable<T>
    
    Specified by:
    
    groupBy in interface MutableCollection<T>
    
    Specified by:
    
    groupBy in interface MutableList<T>
    
    Specified by:
    
    groupBy in interface OrderedIterable<T>
    
    Specified by:
    
    groupBy in interface ReversibleIterable<T>
    
    Specified by:
    
    groupBy in interface RichIterable<T>
    
    Overrides:
    
    groupBy in class AbstractListAdapter<T>
  - groupByEach
```
public <V> FastListMultimap<V,T> groupByEach(Function<? super T,? extends Iterable<V>> function)
```
    Specified by:
    
    groupByEach in interface ListIterable<T>
    
    Specified by:
    
    groupByEach in interface MutableCollection<T>
    
    Specified by:
    
    groupByEach in interface MutableList<T>
    
    Specified by:
    
    groupByEach in interface OrderedIterable<T>
    
    Specified by:
    
    groupByEach in interface ReversibleIterable<T>
    
    Specified by:
    
    groupByEach in interface RichIterable<T>
    
    Overrides:
    
    groupByEach in class AbstractListAdapter<T>
  - selectWith
```
public <P> MutableList<T> selectWith(Predicate2<? super T,? super P> predicate,
                                     P parameter)
```
    Specified by:
    
    selectWith in interface ListIterable<T>
    
    Specified by:
    
    selectWith in interface MutableCollection<T>
    
    Specified by:
    
    selectWith in interface MutableList<T>
    
    Specified by:
    
    selectWith in interface OrderedIterable<T>
    
    Specified by:
    
    selectWith in interface ReversibleIterable<T>
    
    Specified by:
    
    selectWith in interface RichIterable<T>
    
    Overrides:
    
    selectWith in class AbstractListAdapter<T>
  - rejectWith
```
public <P> MutableList<T> rejectWith(Predicate2<? super T,? super P> predicate,
                                     P parameter)
```
    Specified by:
    
    rejectWith in interface ListIterable<T>
    
    Specified by:
    
    rejectWith in interface MutableCollection<T>
    
    Specified by:
    
    rejectWith in interface MutableList<T>
    
    Specified by:
    
    rejectWith in interface OrderedIterable<T>
    
    Specified by:
    
    rejectWith in interface ReversibleIterable<T>
    
    Specified by:
    
    rejectWith in interface RichIterable<T>
    
    Overrides:
    
    rejectWith in class AbstractListAdapter<T>
  - collectWith
```
public <P,V> MutableList<V> collectWith(Function2<? super T,? super P,? extends V> function,
                                              P parameter)
```
    Specified by:
    
    collectWith in interface ListIterable<T>
    
    Specified by:
    
    collectWith in interface MutableCollection<T>
    
    Specified by:
    
    collectWith in interface MutableList<T>
    
    Specified by:
    
    collectWith in interface OrderedIterable<T>
    
    Specified by:
    
    collectWith in interface ReversibleIterable<T>
    
    Specified by:
    
    collectWith in interface RichIterable<T>
    
    Overrides:
    
    collectWith in class AbstractListAdapter<T>
  - distinct
```
public MutableList<T> distinct()
```
    Specified by:
    
    distinct in interface ListIterable<T>
    
    Specified by:
    
    distinct in interface MutableList<T>
    
    Specified by:
    
    distinct in interface OrderedIterable<T>
    
    Specified by:
    
    distinct in interface ReversibleIterable<T>
  - distinct
```
public MutableList<T> distinct(HashingStrategy<? super T> hashingStrategy)
```
    Specified by:
    
    distinct in interface ListIterable<T>
    
    Specified by:
    
    distinct in interface MutableList<T>
  - zip
```
public <S> MutableList<Pair<T,S>> zip(Iterable<S> that)
```
    Specified by:
    
    zip in interface ListIterable<T>
    
    Specified by:
    
    zip in interface MutableCollection<T>
    
    Specified by:
    
    zip in interface MutableList<T>
    
    Specified by:
    
    zip in interface OrderedIterable<T>
    
    Specified by:
    
    zip in interface ReversibleIterable<T>
    
    Specified by:
    
    zip in interface RichIterable<T>
    
    Overrides:
    
    zip in class AbstractListAdapter<T>
  - zipWithIndex
```
public MutableList<Pair<T,Integer>> zipWithIndex()
```
    Specified by:
    
    zipWithIndex in interface ListIterable<T>
    
    Specified by:
    
    zipWithIndex in interface MutableCollection<T>
    
    Specified by:
    
    zipWithIndex in interface MutableList<T>
    
    Specified by:
    
    zipWithIndex in interface OrderedIterable<T>
    
    Specified by:
    
    zipWithIndex in interface ReversibleIterable<T>
    
    Specified by:
    
    zipWithIndex in interface RichIterable<T>
    
    Overrides:
    
    zipWithIndex in class AbstractListAdapter<T>
  - take
```
public MutableList<T> take(int count)
```
    Specified by:
    
    take in interface ListIterable<T>
    
    Specified by:
    
    take in interface MutableList<T>
    
    Specified by:
    
    take in interface ReversibleIterable<T>
  - takeWhile
```
public MutableList<T> takeWhile(Predicate<? super T> predicate)
```
    Specified by:
    
    takeWhile in interface ListIterable<T>
    
    Specified by:
    
    takeWhile in interface MutableList<T>
    
    Specified by:
    
    takeWhile in interface OrderedIterable<T>
    
    Specified by:
    
    takeWhile in interface ReversibleIterable<T>
  - drop
```
public MutableList<T> drop(int count)
```
    Specified by:
    
    drop in interface ListIterable<T>
    
    Specified by:
    
    drop in interface MutableList<T>
    
    Specified by:
    
    drop in interface ReversibleIterable<T>
  - dropWhile
```
public MutableList<T> dropWhile(Predicate<? super T> predicate)
```
    Specified by:
    
    dropWhile in interface ListIterable<T>
    
    Specified by:
    
    dropWhile in interface MutableList<T>
    
    Specified by:
    
    dropWhile in interface OrderedIterable<T>
    
    Specified by:
    
    dropWhile in interface ReversibleIterable<T>
  - partitionWhile
```
public PartitionMutableList<T> partitionWhile(Predicate<? super T> predicate)
```
    Specified by:
    
    partitionWhile in interface ListIterable<T>
    
    Specified by:
    
    partitionWhile in interface MutableList<T>
    
    Specified by:
    
    partitionWhile in interface OrderedIterable<T>
    
    Specified by:
    
    partitionWhile in interface ReversibleIterable<T>

Class RandomAccessListAdapter<T>

Method Summary

Methods inherited from class org.eclipse.collections.impl.list.mutable.AbstractListAdapter

Methods inherited from class org.eclipse.collections.impl.collection.mutable.AbstractCollectionAdapter

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

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

Methods inherited from interface java.util.List

Methods inherited from interface org.eclipse.collections.api.list.ListIterable

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

Methods inherited from interface org.eclipse.collections.api.list.MutableList

Methods inherited from interface org.eclipse.collections.api.ordered.OrderedIterable

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

Method Detail

adapt

toImmutable

asUnmodifiable

asSynchronized

clone

newEmpty

each

reverseForEach

reverseForEachWithIndex

forEachWithIndex

forEachWithIndex

detect

detectIfNone

detectIndex

detectLastIndex

count

corresponds

anySatisfy

allSatisfy

noneSatisfy

injectInto

forEach

sort

sortThis

sortThis

with

with

with

with

without

withAll

withoutAll

select

reject

partition

partitionWith

selectInstancesOf

collect

flatCollect

collectIf

groupBy

groupByEach

selectWith

rejectWith

collectWith

distinct

distinct

zip

zipWithIndex

take

takeWhile

drop

dropWhile

partitionWhile