public class SynchronizedMutableList<T> extends AbstractSynchronizedMutableCollection<T> implements MutableList<T>, Serializable
MutableList. It is imperative that the user manually synchronize on the collection when iterating over it using the
standard JDK iterator or JDK 5 for loop, as per Collections.synchronizedCollection(Collection).MutableList.asSynchronized(),
Serialized Form| Modifier and Type | Method and Description |
|---|---|
void |
add(int index,
T element) |
boolean |
addAll(int index,
Collection<? extends T> collection) |
LazyIterable<T> |
asReversed()
Returns a reversed view of this ListIterable.
|
MutableList<T> |
asSynchronized()
Returns a synchronized (thread-safe) collection backed by this collection.
|
MutableList<T> |
asUnmodifiable()
Returns an unmodifiable view of this collection.
|
int |
binarySearch(T key)
Searches for the specified object using the binary search algorithm.
|
int |
binarySearch(T key,
Comparator<? super T> comparator)
Searches for the specified object using the binary search algorithm.
|
MutableList<T> |
clone() |
<V> MutableList<V> |
collect(Function<? super T,? extends V> function)
Returns a new MutableCollection with the results of applying the specified function to each element of the source
collection.
|
MutableBooleanList |
collectBoolean(BooleanFunction<? super T> booleanFunction)
Returns a new primitive
boolean iterable with the results of applying the specified function on each element
of the source collection. |
MutableByteList |
collectByte(ByteFunction<? super T> byteFunction)
Returns a new primitive
byte iterable with the results of applying the specified function on each element
of the source collection. |
MutableCharList |
collectChar(CharFunction<? super T> charFunction)
Returns a new primitive
char iterable with the results of applying the specified function on each element
of the source collection. |
MutableDoubleList |
collectDouble(DoubleFunction<? super T> doubleFunction)
Returns a new primitive
double iterable with the results of applying the specified function on each element
of the source collection. |
MutableFloatList |
collectFloat(FloatFunction<? super T> floatFunction)
Returns a new primitive
float iterable with the results of applying the specified function on each element
of the source collection. |
<V> MutableList<V> |
collectIf(Predicate<? super T> predicate,
Function<? super T,? extends V> function)
Returns a new MutableCollection with the results of applying the specified function to each element of the source
collection, but only for elements that evaluate to true for the specified predicate.
|
MutableIntList |
collectInt(IntFunction<? super T> intFunction)
Returns a new primitive
int iterable with the results of applying the specified function on each element
of the source collection. |
MutableLongList |
collectLong(LongFunction<? super T> longFunction)
Returns a new primitive
long iterable with the results of applying the specified function on each element
of the source collection. |
MutableShortList |
collectShort(ShortFunction<? super T> shortFunction)
Returns a new primitive
short iterable with the results of applying the specified function on each element
of the source collection. |
<P,V> MutableList<V> |
collectWith(Function2<? super T,? super P,? extends V> function,
P parameter)
Same as collect with a
Function2 and specified parameter which is passed to the block
|
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.
|
boolean |
equals(Object obj)
Follows the same general contract as
List.equals(Object). |
<V> MutableList<V> |
flatCollect(Function<? super T,? extends Iterable<V>> function)
flatCollect is a special case of RichIterable.collect(Function). |
void |
forEach(int fromIndex,
int toIndex,
Procedure<? super T> procedure)
Iterates over the section of the list covered by the specified inclusive indexes.
|
void |
forEachWithIndex(int fromIndex,
int toIndex,
ObjectIntProcedure<? super T> objectIntProcedure)
Iterates over the section of the list covered by the specified inclusive indexes.
|
T |
get(int index)
Returns the item at the specified position in this list iterable.
|
<V> MutableListMultimap<V,T> |
groupBy(Function<? super T,? extends V> function)
For each element of the iterable, the function is evaluated and the results of these evaluations are collected
into a new multimap, where the transformed value is the key and the original values are added to the same (or similar)
species of collection as the source iterable.
|
<V> MutableListMultimap<V,T> |
groupByEach(Function<? super T,? extends Iterable<V>> function)
Similar to
RichIterable.groupBy(Function), except the result of evaluating function will return a collection of keys
for each value. |
int |
hashCode()
Follows the same general contract as
List.hashCode(). |
int |
indexOf(Object o)
Returns the index of the first occurrence of the specified item
in this list, or -1 if this list does not contain the item.
|
int |
lastIndexOf(Object o)
Returns the index of the last occurrence of the specified item
in this list, or -1 if this list does not contain the item.
|
ListIterator<T> |
listIterator() |
ListIterator<T> |
listIterator(int index) |
MutableList<T> |
newEmpty()
Creates a new empty mutable version of the same collection type.
|
static <E,L extends List<E>> |
of(L list)
This method will take a MutableList and wrap it directly in a SynchronizedMutableList.
|
static <E,L extends List<E>> |
of(L list,
Object lock)
This method will take a MutableList and wrap it directly in a SynchronizedMutableList.
|
PartitionMutableList<T> |
partition(Predicate<? super T> predicate)
Filters a collection into a PartitionedIterable based on the evaluation of the predicate.
|
PartitionMutableList<T> |
partitionWhile(Predicate<? super T> predicate)
Returns a Partition of the initial elements that satisfy the Predicate and the remaining elements.
|
<P> PartitionMutableList<T> |
partitionWith(Predicate2<? super T,? super P> predicate,
P parameter)
Filters a collection into a PartitionIterable based on the evaluation of the predicate.
|
MutableList<T> |
reject(Predicate<? super T> predicate)
Returns a MutableCollection with all elements that evaluate to false for the specified predicate.
|
<P> MutableList<T> |
rejectWith(Predicate2<? super T,? super P> predicate,
P parameter)
Returns a MutableCollection with all elements that evaluate to false for the specified predicate2 and parameter.
|
T |
remove(int index) |
void |
reverseForEach(Procedure<? super T> procedure)
Evaluates the procedure for each element of the list iterating in reverse order.
|
MutableList<T> |
reverseThis()
Mutates the current list by reversing its order and returns the current list as a result
|
MutableList<T> |
select(Predicate<? super T> predicate)
Returns a MutableCollection with all elements that evaluate to true for the specified predicate.
|
<S> MutableList<S> |
selectInstancesOf(Class<S> clazz)
Returns all elements of the source collection that are instances of the Class
clazz. |
<P> MutableList<T> |
selectWith(Predicate2<? super T,? super P> predicate,
P parameter)
Returns a MutableCollection with all elements that evaluate to true for the specified predicate2 and parameter.
|
T |
set(int index,
T element) |
MutableList<T> |
sortThis()
Sorts the internal data structure of this list and returns the list itself as a convenience.
|
MutableList<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> |
subList(int fromIndex,
int toIndex) |
MutableList<T> |
takeWhile(Predicate<? super T> predicate)
Returns the initial elements that satisfy the Predicate.
|
ImmutableList<T> |
toImmutable()
Converts this MutableCollection to an ImmutableCollection.
|
MutableList<T> |
toReversed()
Returns a new MutableList in reverse order
|
MutableStack<T> |
toStack()
Converts the list to a mutable MutableStack implementation.
|
MutableList<T> |
with(T element)
This method allows mutable and fixed size collections the ability to add elements to their existing elements.
|
MutableList<T> |
withAll(Iterable<? extends T> elements)
This method allows mutable and fixed size collections the ability to add multiple elements to their existing
elements.
|
MutableList<T> |
without(T element)
This method allows mutable and fixed size collections the ability to remove elements from their existing elements.
|
MutableList<T> |
withoutAll(Iterable<? extends T> elements)
This method allows mutable and fixed size collections the ability to remove multiple elements from their existing
elements.
|
<S> MutableList<Pair<T,S>> |
zip(Iterable<S> that)
Returns a
RichIterable formed from this RichIterable and another RichIterable by
combining corresponding elements in pairs. |
<S,R extends Collection<Pair<T,S>>> |
zip(Iterable<S> that,
R target)
Same as
RichIterable.zip(Iterable) but uses target for output. |
MutableList<Pair<T,Integer>> |
zipWithIndex()
Zips this
RichIterable with its indices. |
<R extends Collection<Pair<T,Integer>>> |
zipWithIndex(R target)
Same as
RichIterable.zipWithIndex() but uses target for output. |
add, addAll, addAllIterable, aggregateBy, aggregateInPlaceBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, clear, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, flatCollect, forEach, forEachWith, forEachWithIndex, getFirst, getLast, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, injectIntoWith, isEmpty, iterator, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, 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, toStringaddAllIterable, aggregateBy, aggregateInPlaceBy, groupByUniqueKey, injectIntoWith, removeAllIterable, removeIf, removeIfWith, retainAllIterable, selectAndRejectWithadd, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, replaceAll, retainAll, size, sort, spliterator, toArray, toArrayparallelStream, removeIf, streamgetFirst, getLastallSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, flatCollect, groupBy, groupByEach, injectInto, injectInto, injectInto, injectInto, injectInto, isEmpty, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, 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, toStringforEach, forEachWith, forEachWithIndexpublic static <E,L extends List<E>> SynchronizedMutableList<E> of(L list)
public static <E,L extends List<E>> SynchronizedMutableList<E> of(L list, Object lock)
public boolean equals(Object obj)
ListIterableList.equals(Object).public int hashCode()
ListIterableList.hashCode().public MutableList<T> asUnmodifiable()
MutableCollectionThe returned collection will be serializable if this collection is serializable.
asUnmodifiable in interface MutableCollection<T>asUnmodifiable in interface MutableList<T>asUnmodifiable in class AbstractSynchronizedMutableCollection<T>public ImmutableList<T> toImmutable()
MutableCollectiontoImmutable in interface MutableCollection<T>toImmutable in interface ListIterable<T>toImmutable in interface MutableList<T>toImmutable in class AbstractSynchronizedMutableCollection<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>asSynchronized in class AbstractSynchronizedMutableCollection<T>public MutableList<T> clone()
clone in interface MutableList<T>clone in class Objectpublic <V> MutableList<V> collect(Function<? super T,? extends V> function)
MutableCollectione.g.
return people.collect(new Function<Person, String>()
{
public String value(Person person)
{
return person.getFirstName() + " " + person.getLastName();
}
});
collect in interface MutableCollection<T>collect in interface ListIterable<T>collect in interface MutableList<T>collect in interface ReversibleIterable<T>collect in interface RichIterable<T>collect in class AbstractSynchronizedMutableCollection<T>public MutableBooleanList collectBoolean(BooleanFunction<? super T> booleanFunction)
RichIterableboolean iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectBoolean(new BooleanFunction<Person>()
{
public boolean booleanValueOf(Person person)
{
return person.hasDrivingLicense();
}
});
collectBoolean in interface MutableCollection<T>collectBoolean in interface ListIterable<T>collectBoolean in interface MutableList<T>collectBoolean in interface ReversibleIterable<T>collectBoolean in interface RichIterable<T>collectBoolean in class AbstractSynchronizedMutableCollection<T>public MutableByteList collectByte(ByteFunction<? super T> byteFunction)
RichIterablebyte iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectByte(new ByteFunction<Person>()
{
public byte byteValueOf(Person person)
{
return person.getCode();
}
});
collectByte in interface MutableCollection<T>collectByte in interface ListIterable<T>collectByte in interface MutableList<T>collectByte in interface ReversibleIterable<T>collectByte in interface RichIterable<T>collectByte in class AbstractSynchronizedMutableCollection<T>public MutableCharList collectChar(CharFunction<? super T> charFunction)
RichIterablechar iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectChar(new CharFunction<Person>()
{
public char charValueOf(Person person)
{
return person.getMiddleInitial();
}
});
collectChar in interface MutableCollection<T>collectChar in interface ListIterable<T>collectChar in interface MutableList<T>collectChar in interface ReversibleIterable<T>collectChar in interface RichIterable<T>collectChar in class AbstractSynchronizedMutableCollection<T>public MutableDoubleList collectDouble(DoubleFunction<? super T> doubleFunction)
RichIterabledouble iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectDouble(new DoubleFunction<Person>()
{
public double doubleValueOf(Person person)
{
return person.getMilesFromNorthPole();
}
});
collectDouble in interface MutableCollection<T>collectDouble in interface ListIterable<T>collectDouble in interface MutableList<T>collectDouble in interface ReversibleIterable<T>collectDouble in interface RichIterable<T>collectDouble in class AbstractSynchronizedMutableCollection<T>public MutableFloatList collectFloat(FloatFunction<? super T> floatFunction)
RichIterablefloat iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectFloat(new FloatFunction<Person>()
{
public float floatValueOf(Person person)
{
return person.getHeightInInches();
}
});
collectFloat in interface MutableCollection<T>collectFloat in interface ListIterable<T>collectFloat in interface MutableList<T>collectFloat in interface ReversibleIterable<T>collectFloat in interface RichIterable<T>collectFloat in class AbstractSynchronizedMutableCollection<T>public MutableIntList collectInt(IntFunction<? super T> intFunction)
RichIterableint iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectInt(new IntFunction<Person>()
{
public int intValueOf(Person person)
{
return person.getAge();
}
});
collectInt in interface MutableCollection<T>collectInt in interface ListIterable<T>collectInt in interface MutableList<T>collectInt in interface ReversibleIterable<T>collectInt in interface RichIterable<T>collectInt in class AbstractSynchronizedMutableCollection<T>public MutableLongList collectLong(LongFunction<? super T> longFunction)
RichIterablelong iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectLong(new LongFunction<Person>()
{
public long longValueOf(Person person)
{
return person.getGuid();
}
});
collectLong in interface MutableCollection<T>collectLong in interface ListIterable<T>collectLong in interface MutableList<T>collectLong in interface ReversibleIterable<T>collectLong in interface RichIterable<T>collectLong in class AbstractSynchronizedMutableCollection<T>public MutableShortList collectShort(ShortFunction<? super T> shortFunction)
RichIterableshort iterable with the results of applying the specified function on each element
of the source collection. This method is also commonly called transform or map.
e.g.
return people.collectShort(new ShortFunction<Person>()
{
public short shortValueOf(Person person)
{
return person.getNumberOfJunkMailItemsReceivedPerMonth();
}
});
collectShort in interface MutableCollection<T>collectShort in interface ListIterable<T>collectShort in interface MutableList<T>collectShort in interface ReversibleIterable<T>collectShort in interface RichIterable<T>collectShort in class AbstractSynchronizedMutableCollection<T>public <V> MutableList<V> flatCollect(Function<? super T,? extends Iterable<V>> function)
RichIterableflatCollect is a special case of RichIterable.collect(Function). With collect, when the Function returns
a collection, the result is a collection of collections. flatCollect outputs a single "flattened" collection
instead. This method is commonly called flatMap.
Consider the following example where we have a Person class, and each Person has a list of Address objects. Take the following Function:
Function<Person, List<Address>> addressFunction = new Function<Person, List<Address>>()
{
public List<Address> valueOf(Person person)
{
return person.getAddresses();
}
};
MutableList<Person> people = ...;
Using collect returns a collection of collections of addresses.
MutableList<List<Address>> addresses = people.collect(addressFunction);Using
flatCollect returns a single flattened list of addresses.
MutableList<Address> addresses = people.flatCollect(addressFunction);
flatCollect in interface MutableCollection<T>flatCollect in interface ListIterable<T>flatCollect in interface MutableList<T>flatCollect in interface ReversibleIterable<T>flatCollect in interface RichIterable<T>flatCollect in class AbstractSynchronizedMutableCollection<T>function - The Function to applyfunctionpublic <V> MutableList<V> collectIf(Predicate<? super T> predicate, Function<? super T,? extends V> function)
MutableCollectione.g. Lists.mutable.of().with(1, 2, 3).collectIf(Predicates.notNull(), Functions.getToString())
collectIf in interface MutableCollection<T>collectIf in interface ListIterable<T>collectIf in interface MutableList<T>collectIf in interface ReversibleIterable<T>collectIf in interface RichIterable<T>collectIf in class AbstractSynchronizedMutableCollection<T>public <P,V> MutableList<V> collectWith(Function2<? super T,? super P,? extends V> function, P parameter)
RichIterableFunction2 and specified parameter which is passed to the block