public final class ListAdapter<T> extends AbstractListAdapter<T> implements Serializable
adapt(List)
factory method.Modifier and Type | Method and Description |
---|---|
static <E> MutableList<E> |
adapt(List<E> list) |
boolean |
allSatisfy(Predicate<? super T> predicate)
Returns true if the predicate evaluates to true for every element of the iterable or if the iterable is empty.
|
boolean |
anySatisfy(Predicate<? super T> predicate)
Returns true if the predicate evaluates to true for any element of the iterable.
|
MutableList<T> |
asSynchronized()
Returns a synchronized (thread-safe) collection backed by this collection.
|
MutableList<T> |
asUnmodifiable()
Returns an unmodifable view of the list.
|
MutableList<T> |
clone() |
int |
count(Predicate<? super T> predicate)
Return the total number of elements that answer true to the specified predicate.
|
T |
detect(Predicate<? super T> predicate)
Returns the first element of the iterable for which the predicate evaluates to true or null in the case where no
element returns true.
|
T |
detectIfNone(Predicate<? super T> predicate,
Function0<? extends T> function)
Returns the first element of the iterable for which the predicate evaluates to true.
|
MutableList<T> |
distinct()
Returns a new
ListIterable containing the distinct elements in this list. |
MutableList<T> |
dropWhile(Predicate<? super T> predicate)
Returns the final elements that do not satisfy the Predicate.
|
void |
forEach(int fromIndex,
int toIndex,
Procedure<? super T> procedure)
Iterates over the section of the list covered by the specified inclusive indexes.
|
void |
forEach(Procedure<? super T> procedure)
The procedure is executed for each element in the iterable.
|
void |
forEachWithIndex(int fromIndex,
int toIndex,
ObjectIntProcedure<? super T> objectIntProcedure)
Iterates over the section of the list covered by the specified inclusive indexes.
|
void |
forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)
Iterates over the iterable passing each element and the current relative int index to the specified instance of
ObjectIntProcedure
|
<IV> IV |
injectInto(IV injectedValue,
Function2<? super IV,? super T,? extends IV> function)
Returns the final result of evaluating function using each element of the iterable and the previous evaluation
result as the parameters.
|
MutableList<T> |
newEmpty()
Deprecated.
use
FastList.newList() instead (inlineable) |
boolean |
noneSatisfy(Predicate<? super T> predicate)
Returns true if the predicate evaluates to false for every element of the iterable or if the iterable is empty.
|
PartitionMutableList<T> |
partitionWhile(Predicate<? super T> predicate)
Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements.
|
void |
reverseForEach(Procedure<? super T> procedure)
Evaluates the procedure for each element of the list iterating in reverse order.
|
<S> MutableList<S> |
selectInstancesOf(Class<S> clazz)
Returns all elements of the source collection that are instances of the Class
clazz . |
ListAdapter<T> |
sortThis()
Sorts the internal data structure of this list and returns the list itself as a convenience.
|
ListAdapter<T> |
sortThis(Comparator<? super T> comparator)
Sorts the internal data structure of this list and returns the list itself as a convenience.
|
<V extends Comparable<? super V>> |
sortThisBy(Function<? super T,? extends V> function)
Sorts the internal data structure of this list based on the natural order of the attribute returned by
function . |
MutableList<T> |
takeWhile(Predicate<? super T> predicate)
Returns the initial elements that satisfy the Predicate.
|
ImmutableList<T> |
toImmutable()
Returns an immutable copy of this list.
|
MutableStack<T> |
toStack()
Converts the list to a mutable MutableStack implementation.
|
ListAdapter<T> |
with(T... elements) |
ListAdapter<T> |
with(T element)
This method allows mutable and fixed size collections the ability to add elements to their existing elements.
|
ListAdapter<T> |
with(T element1,
T element2) |
ListAdapter<T> |
with(T element1,
T element2,
T element3) |
ListAdapter<T> |
withAll(Iterable<? extends T> elements)
This method allows mutable and fixed size collections the ability to add multiple elements to their existing
elements.
|
ListAdapter<T> |
without(T element)
This method allows mutable and fixed size collections the ability to remove elements from their existing elements.
|
ListAdapter<T> |
withoutAll(Iterable<? extends T> elements)
This method allows mutable and fixed size collections the ability to remove multiple elements from their existing
elements.
|
add, addAll, asReversed, binarySearch, binarySearch, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, equals, flatCollect, get, groupBy, groupByEach, hashCode, indexOf, lastIndexOf, listIterator, listIterator, partition, partitionWith, reject, rejectWith, remove, reverseThis, select, selectWith, set, subList, toReversed, zip, zipWithIndex
add, addAll, addAllIterable, aggregateBy, aggregateInPlaceBy, allSatisfyWith, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, clear, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, countWith, detectWith, detectWithIfNone, flatCollect, forEachWith, getFirst, getLast, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectIntoWith, isEmpty, iterator, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfyWith, notEmpty, reject, rejectWith, remove, removeAll, removeAllIterable, removeIf, removeIfWith, retainAll, retainAllIterable, select, selectAndRejectWith, selectWith, size, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex
addAllIterable, aggregateBy, aggregateInPlaceBy, groupByUniqueKey, injectIntoWith, removeAllIterable, removeIf, removeIfWith, retainAllIterable, selectAndRejectWith
add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, replaceAll, retainAll, size, sort, spliterator, toArray, toArray
parallelStream, removeIf, stream
getFirst, getLast
allSatisfyWith, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, countWith, detectWith, detectWithIfNone, flatCollect, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfyWith, notEmpty, reject, rejectWith, select, selectWith, size, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndex
forEachWith
public static <E> MutableList<E> adapt(List<E> list)
public ImmutableList<T> toImmutable()
MutableList
toImmutable
in interface MutableCollection<T>
toImmutable
in interface ListIterable<T>
toImmutable
in interface MutableList<T>
public MutableList<T> asUnmodifiable()
MutableList
asUnmodifiable
in interface MutableCollection<T>
asUnmodifiable
in interface MutableList<T>
public MutableList<T> asSynchronized()
MutableCollection
MutableCollection collection = myCollection.asSynchronized(); ... synchronized(collection) { Iterator i = c.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior. The preferred way of iterating over a synchronized collection is to use the collection.forEach() method which is properly synchronized internally.
MutableCollection collection = myCollection.asSynchronized(); ... collection.forEach(new Procedure() { public void value(Object each) { ... } });The returned collection does not pass the hashCode and equals operations through to the backing collection, but relies on Object's equals and hashCode methods. This is necessary to preserve the contracts of these operations in the case that the backing collection is a set or a list. The returned collection will be serializable if this collection is serializable.
asSynchronized
in interface MutableCollection<T>
asSynchronized
in interface MutableList<T>
public MutableList<T> clone()
clone
in interface MutableList<T>
clone
in class AbstractListAdapter<T>
@Deprecated public MutableList<T> newEmpty()
FastList.newList()
instead (inlineable)MutableCollection
newEmpty
in interface MutableCollection<T>
newEmpty
in interface MutableList<T>
public void forEach(Procedure<? super T> procedure)
InternalIterable
e.g. people.forEach(new Procedure() { public void value(Person person) { LOGGER.info(person.getName()); } });
forEach
in interface InternalIterable<T>
forEach
in class AbstractCollectionAdapter<T>
public void reverseForEach(Procedure<? super T> procedure)
ReversibleIterable
e.g. people.reverseForEach(new Procedure() { public void value(Person person) { LOGGER.info(person.getName()); } });
reverseForEach
in interface ReversibleIterable<T>
public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)
InternalIterable
e.g. people.forEachWithIndex(new ObjectIntProcedure() { public void value(Person person, int index) { LOGGER.info("Index: " + index + " person: " + person.getName()); } });
forEachWithIndex
in interface InternalIterable<T>
forEachWithIndex
in class AbstractCollectionAdapter<T>
public void forEachWithIndex(int fromIndex, int toIndex, ObjectIntProcedure<? super T> objectIntProcedure)
ListIterable
e.g. ListIterableThis code would output ted and mary's names.people = FastList.newListWith(ted, mary, bob, sally) people.forEachWithIndex(0, 1, new ObjectIntProcedure () { public void value(Person person, int index) { LOGGER.info(person.getName()); } });
forEachWithIndex
in interface ListIterable<T>
public T detect(Predicate<? super T> predicate)
RichIterable
e.g. return people.detect(new Predicate<Person>() { public boolean value(Person person) { return person.getFirstName().equals("John") && person.getLastName().equals("Smith"); } });
detect
in interface RichIterable<T>
detect
in class AbstractCollectionAdapter<T>
public T detectIfNone(Predicate<? super T> predicate, Function0<? extends T> function)
RichIterable
detectIfNone
in interface RichIterable<T>
detectIfNone
in class AbstractCollectionAdapter<T>
public int count(Predicate<? super T> predicate)
RichIterable
e.g. return people.count(new Predicate<Person>() { public boolean value(Person person) { return person.getAddress().getState().getName().equals("New York"); } });
count
in interface RichIterable<T>
count
in class AbstractCollectionAdapter<T>
public boolean anySatisfy(Predicate<? super T> predicate)
RichIterable
anySatisfy
in interface RichIterable<T>
anySatisfy
in class AbstractCollectionAdapter<T>
public boolean allSatisfy(Predicate<? super T> predicate)
RichIterable
allSatisfy
in interface RichIterable<T>
allSatisfy
in class AbstractCollectionAdapter<T>
public boolean noneSatisfy(Predicate<? super T> predicate)
RichIterable
noneSatisfy
in interface RichIterable<T>
noneSatisfy
in class AbstractCollectionAdapter<T>
public <IV> IV injectInto(IV injectedValue, Function2<? super IV,? super T,? extends IV> function)
RichIterable
injectInto
in interface RichIterable<T>
injectInto
in class AbstractCollectionAdapter<T>
public void forEach(int fromIndex, int toIndex, Procedure<? super T> procedure)
ListIterable
e.g. ListIterableThis code would output ted and mary's names.people = FastList.newListWith(ted, mary, bob, sally) people.forEach(0, 1, new Procedure () { public void value(Person person) { LOGGER.info(person.getName()); } });
forEach
in interface ListIterable<T>
public ListAdapter<T> sortThis(Comparator<? super T> comparator)
MutableList
sortThis
in interface MutableList<T>
public ListAdapter<T> sortThis()
MutableList
sortThis
in interface MutableList<T>
public <V extends Comparable<? super V>> MutableList<T> sortThisBy(Function<? super T,? extends V> function)
MutableList
function
.sortThisBy
in interface MutableList<T>
public ListAdapter<T> with(T element)
MutableCollection
MutableCollectionIn the case oflist; list = list.with("1"); list = list.with("2"); return list;
FixedSizeCollection
a new instance of MutableCollection will be returned by with, and any
variables that previously referenced the original collection will need to be redirected to reference the
new instance. For other MutableCollection types you will replace the reference to collection with the same
collection, since the instance will return "this" after calling add on itself.with
in interface MutableCollection<T>
with
in interface MutableList<T>
Collection.add(Object)
public ListAdapter<T> with(T element1, T element2)
public ListAdapter<T> with(T element1, T element2, T element3)
public ListAdapter<T> with(T... elements)
public ListAdapter<T> without(T element)
MutableCollection
MutableCollectionIn the case oflist; list = list.without("1"); list = list.without("2"); return list;
FixedSizeCollection
a new instance of MutableCollection will be returned by without, and
any variables that previously referenced the original collection will need to be redirected to reference the
new instance. For other MutableCollection types you will replace the reference to collection with the same
collection, since the instance will return "this" after calling remove on itself.without
in interface MutableCollection<T>
without
in interface MutableList<T>
Collection.remove(Object)
public ListAdapter<T> withAll(Iterable<? extends T> elements)
MutableCollection
MutableCollectionIn the case oflist; list = list.withAll(FastList.newListWith("1", "2")); return list;
FixedSizeCollection
a new instance of MutableCollection will be returned by withAll, and
any variables that previously referenced the original collection will need to be redirected to reference the
new instance. For other MutableCollection types you will replace the reference to collection with the same
collection, since the instance will return "this" after calling addAll on itself.withAll
in interface MutableCollection<T>
withAll
in interface MutableList<T>
Collection.addAll(Collection)
public ListAdapter<T> withoutAll(Iterable<? extends T> elements)
MutableCollection
MutableCollectionIn the case oflist; list = list.withoutAll(FastList.newListWith("1", "2")); return list;
FixedSizeCollection
a new instance of MutableCollection will be returned by withoutAll,
and any variables that previously referenced the original collection will need to be redirected to reference the
new instance. For other MutableCollection types you will replace the reference to collection with the same
collection, since the instance will return "this" after calling removeAll on itself.withoutAll
in interface MutableCollection<T>
withoutAll
in interface MutableList<T>
Collection.removeAll(Collection)
public <S> MutableList<S> selectInstancesOf(Class<S> clazz)
RichIterable
clazz
.selectInstancesOf
in interface MutableCollection<T>
selectInstancesOf
in interface ListIterable<T>
selectInstancesOf
in interface MutableList<T>
selectInstancesOf
in interface ReversibleIterable<T>
selectInstancesOf
in interface RichIterable<T>
selectInstancesOf
in class AbstractListAdapter<T>
public MutableList<T> distinct()
ListIterable
ListIterable
containing the distinct elements in this list.
Conceptually similar to RichIterable.toSet()
.RichIterable.toList()
but retains the original order. If an element appears
multiple times in this list, the first one will be copied into the result.distinct
in interface ListIterable<T>
distinct
in interface MutableList<T>
distinct
in interface ReversibleIterable<T>
ListIterable
of distinct elementspublic MutableList<T> takeWhile(Predicate<? super T> predicate)
ListIterable
takeWhile
in interface ListIterable<T>
takeWhile
in interface MutableList<T>
takeWhile
in interface ReversibleIterable<T>
public MutableList<T> dropWhile(Predicate<? super T> predicate)
ListIterable
dropWhile
in interface ListIterable<T>
dropWhile
in interface MutableList<T>
dropWhile
in interface ReversibleIterable<T>
public PartitionMutableList<T> partitionWhile(Predicate<? super T> predicate)
ListIterable
partitionWhile
in interface ListIterable<T>
partitionWhile
in interface MutableList<T>
partitionWhile
in interface ReversibleIterable<T>
public MutableStack<T> toStack()
ListIterable
toStack
in interface ListIterable<T>
toStack
in interface ReversibleIterable<T>
toStack
in class AbstractListAdapter<T>
Copyright © 2004–2017. All rights reserved.