java.io.Serializable, java.lang.Cloneable, java.lang.Iterable<T>, java.util.Collection<T>, java.util.List<T>, MutableCollection<T>, InternalIterable<T>, ListIterable<T>, MutableList<T>, OrderedIterable<T>, ReversibleIterable<T>, RichIterable<T>public final class ListAdapter<T> extends AbstractListAdapter<T> implements java.io.Serializable
To create a new wrapper around an existing List instance, use the adapt(List) factory method.
| Modifier and Type | Method | Description |
|---|---|---|
static <E> MutableList<E> |
adapt(java.util.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.
|
ParallelListIterable<T> |
asParallel(java.util.concurrent.ExecutorService executorService,
int batchSize) |
Returns a parallel iterable of this ListIterable.
|
MutableList<T> |
asSynchronized() |
Returns a synchronized wrapper backed by this collection.
|
MutableList<T> |
asUnmodifiable() |
Returns an unmodifiable view of the list.
|
MutableList<T> |
clone() |
|
<S> boolean |
corresponds(OrderedIterable<S> other,
Predicate2<? super T,? super S> predicate) |
Returns true if both OrderedIterables have the same length
and
predicate returns true for all corresponding elements e1 of
this OrderedIterable and e2 of other. |
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.
|
int |
detectIndex(Predicate<? super T> predicate) |
Returns the index of the first element of the
OrderedIterable for which the predicate evaluates to true. |
int |
detectLastIndex(Predicate<? super T> predicate) |
Returns the index of the last element of the
ReversibleIterable for which the predicate evaluates to true. |
MutableList<T> |
distinct() |
Returns a new
ListIterable containing the distinct elements in this list. |
MutableList<T> |
distinct(HashingStrategy<? super T> hashingStrategy) |
Returns a new
ListIterable containing the distinct elements in this list. |
MutableList<T> |
drop(int count) |
Returns an iterable after skipping the first
count elements
or an empty iterable if the count is greater than the length of the iterable. |
MutableList<T> |
dropWhile(Predicate<? super T> predicate) |
Returns the final elements that do not satisfy the Predicate.
|
void |
each(Procedure<? super T> procedure) |
The procedure is executed for each element in the iterable.
|
void |
forEach(int fromIndex,
int toIndex,
Procedure<? super T> procedure) |
Iterates over the section of the iterable 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 iterable 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.
|
void |
reverseForEachWithIndex(ObjectIntProcedure<? super T> procedure) |
Evaluates the procedure for each element and it's index in reverse order.
|
<S> MutableList<S> |
selectInstancesOf(java.lang.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(java.util.Comparator<? super T> comparator) |
Sorts the internal data structure of this list and returns the list itself as a convenience.
|
MutableList<T> |
take(int count) |
Returns the first
count elements of the iterable
or all the elements in the iterable if count is greater than the length of
the iterable. |
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 element) |
This method allows mutable and fixed size collections the ability to add elements to their existing elements.
|
ListAdapter<T> |
with(T... elements) |
|
ListAdapter<T> |
with(T element1,
T element2) |
|
ListAdapter<T> |
with(T element1,
T element2,
T element3) |
|
ListAdapter<T> |
withAll(java.lang.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(java.lang.Iterable<? extends T> elements) |
This method allows mutable and fixed size collections the ability to remove multiple elements from their existing
elements.
|
add, addAll, addAllIterable, aggregateBy, aggregateInPlaceBy, 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, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toString, zip, zipWithIndexadd, addAll, asReversed, binarySearch, binarySearch, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, distinctBy, equals, flatCollect, get, groupBy, groupByEach, hashCode, indexOf, lastIndexOf, listIterator, listIterator, partition, partitionWith, reject, rejectWith, remove, reverseThis, select, selectWith, set, shuffleThis, shuffleThis, sortThisBy, sortThisByBoolean, sortThisByByte, sortThisByChar, sortThisByDouble, sortThisByFloat, sortThisByInt, sortThisByLong, sortThisByShort, subList, tap, toReversed, zip, zipWithIndexforEachWithadd, addAll, clear, contains, containsAll, isEmpty, iterator, of, of, of, of, of, of, of, of, of, of, of, of, remove, removeAll, replaceAll, retainAll, size, sort, spliterator, toArray, toArraygetFirst, getLastaddAllIterable, aggregateBy, aggregateInPlaceBy, countBy, countByWith, groupByUniqueKey, injectIntoWith, removeAllIterable, removeIf, removeIfWith, retainAllIterable, selectAndRejectWith, sumByDouble, sumByFloat, sumByInt, sumByLongcollectWithIndexcollectWithIndex, getFirstOptional, getLastOptionalallSatisfyWith, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, countBy, countByWith, countWith, detectOptional, detectWith, detectWithIfNone, detectWithOptional, flatCollect, getOnly, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, into, isEmpty, 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, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, toStringpublic static <E> MutableList<E> adapt(java.util.List<E> list)
public ImmutableList<T> toImmutable()
MutableListtoImmutable in interface ListIterable<T>toImmutable in interface MutableCollection<T>toImmutable in interface MutableList<T>public MutableList<T> asUnmodifiable()
MutableListasUnmodifiable in interface MutableCollection<T>asUnmodifiable in interface MutableList<T>Collections.unmodifiableCollection(Collection)public MutableList<T> asSynchronized()
MutableCollectionCollections.synchronizedCollection(this) only with a return type that supports the full
iteration protocols available on MutableCollection.
The preferred way of iterating over a synchronized collection is to use the internal iteration
methods which are properly synchronized internally.
MutableCollection synchedCollection = collection.asSynchronized();
...
synchedCollection.forEach(each -> ... );
synchedCollection.select(each -> ... );
synchedCollection.collect(each -> ... );
If you want to iterate using an imperative style, you must protect external iterators using
a synchronized block. This includes explicit iterators as well as JDK 5 style for loops.
asSynchronized in interface MutableCollection<T>asSynchronized in interface MutableList<T>Collections.synchronizedCollection(Collection)public MutableList<T> clone()
clone in interface MutableList<T>clone in class AbstractListAdapter<T>@Deprecated public MutableList<T> newEmpty()
FastList.newList() instead (inlineable)MutableCollectionnewEmpty in interface MutableCollection<T>newEmpty in interface MutableList<T>public void forEach(Procedure<? super T> procedure)
InternalIterableExample using a Java 8 lambda:
people.forEach(Procedures.cast(person -> LOGGER.info(person.getName())));
Example using an anonymous inner class:
people.forEach(new Procedure<Person>()
{
public void value(Person person)
{
LOGGER.info(person.getName());
}
});
NOTE: This method started to conflict with Iterable.forEach(java.util.function.Consumer)
since Java 1.8. It is recommended to use RichIterable.each(Procedure) instead to avoid casting to Procedure.forEach in interface InternalIterable<T>forEach in class AbstractCollectionAdapter<T>RichIterable.each(Procedure),
Iterable.forEach(java.util.function.Consumer)public void each(Procedure<? super T> procedure)
RichIterableExample using a Java 8 lambda expression:
people.each(person -> LOGGER.info(person.getName()));
Example using an anonymous inner class:
people.each(new Procedure<Person>()
{
public void value(Person person)
{
LOGGER.info(person.getName());
}
});
This method is a variant of InternalIterable.forEach(Procedure)
that has a signature conflict with Iterable.forEach(java.util.function.Consumer).each in interface RichIterable<T>each in class AbstractCollectionAdapter<T>InternalIterable.forEach(Procedure),
Iterable.forEach(java.util.function.Consumer)public void reverseForEach(Procedure<? super T> procedure)
ReversibleIterable
e.g. people.reverseForEach(person -> LOGGER.info(person.getName()));
reverseForEach in interface ReversibleIterable<T>public void reverseForEachWithIndex(ObjectIntProcedure<? super T> procedure)
ReversibleIterablee.g.
people.reverseForEachWithIndex((person, index) ->
LOGGER.info("Index: " + index + " person: " + person.getName()));
reverseForEachWithIndex in interface ReversibleIterable<T>public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)
InternalIterableExample using a Java 8 lambda:
people.forEachWithIndex((Person person, int index) -> LOGGER.info("Index: " + index + " person: " + person.getName()));
Example using an anonymous inner class:
people.forEachWithIndex(new ObjectIntProcedure<Person>()
{
public void value(Person person, int index)
{
LOGGER.info("Index: " + index + " person: " + person.getName());
}
});
forEachWithIndex in interface InternalIterable<T>forEachWithIndex in interface OrderedIterable<T>forEachWithIndex in class AbstractCollectionAdapter<T>public void forEachWithIndex(int fromIndex,
int toIndex,
ObjectIntProcedure<? super T> objectIntProcedure)
OrderedIterable
e.g.
OrderedIterable<People> people = FastList.newListWith(ted, mary, bob, sally)
people.forEachWithIndex(0, 1, new ObjectIntProcedure<Person>()
{
public void value(Person person, int index)
{
LOGGER.info(person.getName());
}
});
This code would output ted and mary's names.
forEachWithIndex in interface OrderedIterable<T>public T detect(Predicate<? super T> predicate)
RichIterableExample using a Java 8 lambda expression:
Person person =
people.detect(person -> person.getFirstName().equals("John") && person.getLastName().equals("Smith"));
Example using an anonymous inner class:
Person person =
people.detect(new Predicate<Person>()
{
public boolean accept(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)
RichIterabledetectIfNone in interface RichIterable<T>detectIfNone in class AbstractCollectionAdapter<T>public int detectIndex(Predicate<? super T> predicate)
OrderedIterableOrderedIterable for which the predicate evaluates to true.
Returns -1 if no element evaluates true for the predicate.detectIndex in interface OrderedIterable<T>public int detectLastIndex(Predicate<? super T> predicate)
ReversibleIterableReversibleIterable for which the predicate evaluates to true.
Returns -1 if no element evaluates true for the predicate.detectLastIndex in interface ReversibleIterable<T>public int count(Predicate<? super T> predicate)
RichIterableExample using a Java 8 lambda expression:
int count =
people.count(person -> person.getAddress().getState().getName().equals("New York"));
Example using an anonymous inner class:
int count =
people.count(new Predicate<Person>()
{
public boolean accept(Person person)
{
return person.getAddress().getState().getName().equals("New York");
}
});
count in interface RichIterable<T>count in class AbstractCollectionAdapter<T>public <S> boolean corresponds(OrderedIterable<S> other, Predicate2<? super T,? super S> predicate)
OrderedIterablepredicate returns true for all corresponding elements e1 of
this OrderedIterable and e2 of other.
The predicate is evaluated for each element at the same position of each OrderedIterable in a forward iteration order.
This is a short circuit pattern.corresponds in interface OrderedIterable<T>public boolean anySatisfy(Predicate<? super T> predicate)
RichIterableanySatisfy in interface RichIterable<T>anySatisfy in class AbstractCollectionAdapter<T>public boolean allSatisfy(Predicate<? super T> predicate)
RichIterableallSatisfy in interface RichIterable<T>allSatisfy in class AbstractCollectionAdapter<T>public boolean noneSatisfy(Predicate<? super T> predicate)
RichIterablenoneSatisfy in interface RichIterable<T>noneSatisfy in class AbstractCollectionAdapter<T>public <IV> IV injectInto(IV injectedValue,
Function2<? super IV,? super T,? extends IV> function)
RichIterableinjectInto in interface RichIterable<T>injectInto in class AbstractCollectionAdapter<T>public void forEach(int fromIndex,
int toIndex,
Procedure<? super T> procedure)
OrderedIterable
e.g.
OrderedIterable<People> people = FastList.newListWith(ted, mary, bob, sally)
people.forEach(0, 1, new Procedure<Person>()
{
public void value(Person person)
{
LOGGER.info(person.getName());
}
});
This code would output ted and mary's names.
forEach in interface OrderedIterable<T>public ListAdapter<T> sortThis(java.util.Comparator<? super T> comparator)
MutableListsortThis in interface MutableList<T>public ListAdapter<T> sortThis()
MutableListsortThis in interface MutableList<T>public ListAdapter<T> with(T element)
MutableCollection
MutableCollection<String> list = list.with("1");
list = list.with("2");
return list;
In the case of 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
MutableCollection<String> list = list.without("1");
list = list.without("2");
return list;
In the case of 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(java.lang.Iterable<? extends T> elements)
MutableCollection
MutableCollection<String> list = list.withAll(FastList.newListWith("1", "2"));
In the case of 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(java.lang.Iterable<? extends T> elements)
MutableCollection
MutableCollection<String> list = list.withoutAll(FastList.newListWith("1", "2"));
In the case of 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(java.lang.Class<S> clazz)
MutableCollectionclazz.
RichIterable<Integer> integers =
List.mutable.with(new Integer(0), new Long(0L), new Double(0.0)).selectInstancesOf(Integer.class);
Co-variant example for MutableCollection:
MutableCollection<Integer> integers =
List.mutable.with(new Integer(0), new Long(0L), new Double(0.0)).selectInstancesOf(Integer.class);
selectInstancesOf in interface ListIterable<T>selectInstancesOf in interface MutableCollection<T>selectInstancesOf in interface MutableList<T>selectInstancesOf in interface OrderedIterable<T>selectInstancesOf in interface ReversibleIterable<T>selectInstancesOf in interface RichIterable<T>selectInstancesOf in class AbstractListAdapter<T>public MutableList<T> distinct()
MutableListListIterable containing the distinct elements in this list.distinct in interface ListIterable<T>distinct in interface MutableList<T>distinct in interface OrderedIterable<T>distinct in interface ReversibleIterable<T>ListIterable of distinct elementspublic MutableList<T> distinct(HashingStrategy<? super T> hashingStrategy)
MutableListListIterable containing the distinct elements in this list. Takes HashingStrategy.distinct in interface ListIterable<T>distinct in interface MutableList<T>ListIterable of distinct elementspublic MutableList<T> take(int count)
ReversibleIterablecount elements of the iterable
or all the elements in the iterable if count is greater than the length of
the iterable.take in interface ListIterable<T>take in interface MutableList<T>take in interface ReversibleIterable<T>count - the number of items to take.public MutableList<T> takeWhile(Predicate<? super T> predicate)
ListIterabletakeWhile in interface ListIterable<T>takeWhile in interface MutableList<T>takeWhile in interface OrderedIterable<T>takeWhile in interface ReversibleIterable<T>public MutableList<T> drop(int count)
ReversibleIterablecount elements
or an empty iterable if the count is greater than the length of the iterable.drop in interface ListIterable<T>drop in interface MutableList<T>drop in interface ReversibleIterable<T>count - the number of items to drop.public MutableList<T> dropWhile(Predicate<? super T> predicate)
ListIterabledropWhile in interface ListIterable<T>dropWhile in interface MutableList<T>dropWhile in interface OrderedIterable<T>dropWhile in interface ReversibleIterable<T>public PartitionMutableList<T> partitionWhile(Predicate<? super T> predicate)
ListIterablepartitionWhile in interface ListIterable<T>partitionWhile in interface MutableList<T>partitionWhile in interface OrderedIterable<T>partitionWhile in interface ReversibleIterable<T>public MutableStack<T> toStack()
ListIterabletoStack in interface ListIterable<T>toStack in interface OrderedIterable<T>toStack in class AbstractListAdapter<T>public ParallelListIterable<T> asParallel(java.util.concurrent.ExecutorService executorService, int batchSize)
ListIterableasParallel in interface ListIterable<T>asParallel in class AbstractListAdapter<T>Copyright © 2004–2018. All rights reserved.