java.io.Serializable, java.lang.Cloneable, java.lang.Iterable<T>, java.util.Collection<T>, java.util.List<T>, FixedSizeCollection<T>, MutableCollection<T>, InternalIterable<T>, FixedSizeList<T>, ListIterable<T>, MutableList<T>, OrderedIterable<T>, ReversibleIterable<T>, RichIterable<T>public final class ArrayAdapter<T> extends AbstractArrayAdapter<T> implements java.io.Serializable, FixedSizeList<T>
AbstractMutableCollection.add(Object), AbstractArrayAdapter.addAll(Collection), AbstractArrayAdapter.remove(Object), AbstractArrayAdapter.removeAll(Collection), etc. are not supported and will throw
an UnsupportedOperationException. In addition, the mutating iteration methods AbstractArrayAdapter.removeIf(org.eclipse.collections.api.block.predicate.Predicate) and AbstractArrayAdapter.removeIfWith(org.eclipse.collections.api.block.predicate.Predicate2, Object) are not supported and will also
throw an UnsupportedOperationException.
The with(Object) method is not an exception to the above restrictions, as it will create a new
instance of this class with the existing contents plus the new item.
To create a wrapper around an existing array, use the adapt(Object[]) factory method. To wrap the contents
of an existing Collection instance, use the newArray(Iterable) or newArrayWithItem(Iterable, Object)
factory methods. To wrap existing objects in a new array, use one of the newArrayWith(Object) factory methods.
| Modifier and Type | Method | Description |
|---|---|---|
static <E> ArrayAdapter<E> |
adapt(E... array) |
|
ArrayAdapter<T> |
clone() |
|
static <E> ArrayAdapter<E> |
newArray() |
|
static <E> ArrayAdapter<E> |
newArray(java.lang.Iterable<? extends E> source) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E one) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E... elements) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E one,
E two) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E one,
E two,
E three) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E one,
E two,
E three,
E four) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E one,
E two,
E three,
E four,
E five) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E one,
E two,
E three,
E four,
E five,
E six) |
|
static <E> ArrayAdapter<E> |
newArrayWith(E one,
E two,
E three,
E four,
E five,
E six,
E seven) |
|
static <E> ArrayAdapter<E> |
newArrayWithItem(java.lang.Iterable<? extends E> iterable,
E itemToAdd) |
|
T |
set(int index,
T element) |
|
ArrayAdapter<T> |
sortThis(java.util.Comparator<? super T> comparator) |
Sorts the internal data structure of this list and returns the list itself as a convenience.
|
java.util.Spliterator<T> |
spliterator() |
|
FixedSizeList<T> |
tap(Procedure<? super T> procedure) |
Executes the Procedure for each element in the iterable and returns
this. |
FixedSizeList<T> |
toReversed() |
Returns a new MutableList in reverse order.
|
ArrayAdapter<T> |
with(T value) |
This method allows mutable and fixed size collections the ability to add elements to their existing elements.
|
ArrayAdapter<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.
|
ArrayAdapter<T> |
without(T element) |
This method allows mutable and fixed size collections the ability to remove elements from their existing elements.
|
ArrayAdapter<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.
|
abstractArrayAdapterEquals, add, addAll, addAll, addAllIterable, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, clear, collect, collect, collectIf, collectIf, collectWith, collectWith, contains, containsAll, corresponds, count, countWith, detect, detectIndex, detectLastIndex, detectOptional, detectWith, detectWithOptional, distinct, distinct, drop, each, equals, flatCollect, flatCollect, forEach, forEachWith, forEachWithIndex, forEachWithIndex, get, getFirst, getLast, hashCode, indexOf, injectInto, injectIntoWith, isEmpty, iterator, lastIndexOf, listIterator, noneSatisfy, noneSatisfyWith, notEmpty, reject, reject, rejectWith, rejectWith, remove, remove, removeAll, removeAllIterable, removeIf, removeIfWith, retainAll, retainAllIterable, select, select, selectAndRejectWith, selectWith, selectWith, size, subList, take, toArray, toArrayadd, aggregateBy, aggregateInPlaceBy, countBy, countByWith, reduce, sumByDouble, sumByFloat, sumByInt, sumByLongappendString, asParallel, asReversed, asSynchronized, asUnmodifiable, binarySearch, chunk, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, distinctBy, dropWhile, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, listIterator, max, max, maxBy, min, min, minBy, newEmpty, partition, partitionWhile, partitionWith, reverseForEach, reverseForEachWithIndex, reverseThis, selectInstancesOf, shuffleThis, shuffleThis, sortThis, sortThisBy, sortThisByBoolean, sortThisByByte, sortThisByChar, sortThisByDouble, sortThisByFloat, sortThisByInt, sortThisByLong, sortThisByShort, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, takeWhile, toImmutable, toList, toSet, toSortedList, toSortedList, toStack, zip, zip, zipWithIndex, zipWithIndexasLazy, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, containsAllArguments, containsAllIterable, detectWithIfNone, forEach, groupBy, groupByEach, groupByUniqueKey, injectInto, into, toBag, toMap, toSortedBag, toSortedBag, toSortedBagBy, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toStringadd, addAll, addAllIterable, clear, remove, removeAll, removeAllIterable, removeIf, removeIfWith, retainAll, retainAllIterableforEach, forEachWithadd, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, of, of, of, of, of, of, of, of, of, of, of, of, remove, remove, removeAll, replaceAll, retainAll, size, sort, toArray, toArrayasParallel, binarySearch, binarySearch, equals, get, getFirst, getLast, hashCode, lastIndexOf, listIterator, listIterator, toStackaggregateBy, aggregateInPlaceBy, countBy, countByWith, groupByUniqueKey, injectIntoWith, selectAndRejectWith, sumByDouble, sumByFloat, sumByInt, sumByLongasSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, collectWithIndex, distinct, distinct, distinctBy, drop, dropWhile, flatCollect, flatCollectWith, groupBy, groupByEach, newEmpty, partition, partitionWhile, partitionWith, reject, rejectWith, reverseThis, select, selectInstancesOf, selectWith, shuffleThis, shuffleThis, sortThis, sortThisBy, sortThisByBoolean, sortThisByByte, sortThisByChar, sortThisByDouble, sortThisByFloat, sortThisByInt, sortThisByLong, sortThisByShort, subList, take, takeWhile, toImmutable, zip, zipWithIndexcollectWithIndex, corresponds, detectIndex, forEach, forEachWithIndex, forEachWithIndex, getFirstOptional, getLastOptional, indexOfasReversed, detectLastIndex, reverseForEach, reverseForEachWithIndexallSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countBy, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectWith, getOnly, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, isEmpty, makeString, makeString, makeString, max, maxBy, maxByOptional, maxOptional, maxOptional, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, 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, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, toStringpublic static <E> ArrayAdapter<E> adapt(E... array)
public static <E> ArrayAdapter<E> newArray()
public static <E> ArrayAdapter<E> newArray(java.lang.Iterable<? extends E> source)
public java.util.Spliterator<T> spliterator()
public static <E> ArrayAdapter<E> newArrayWithItem(java.lang.Iterable<? extends E> iterable, E itemToAdd)
public static <E> ArrayAdapter<E> newArrayWith(E one)
public static <E> ArrayAdapter<E> newArrayWith(E one, E two)
public static <E> ArrayAdapter<E> newArrayWith(E one, E two, E three)
public static <E> ArrayAdapter<E> newArrayWith(E one, E two, E three, E four)
public static <E> ArrayAdapter<E> newArrayWith(E one, E two, E three, E four, E five)
public static <E> ArrayAdapter<E> newArrayWith(E one, E two, E three, E four, E five, E six)
public static <E> ArrayAdapter<E> newArrayWith(E one, E two, E three, E four, E five, E six, E seven)
public static <E> ArrayAdapter<E> newArrayWith(E... elements)
public ArrayAdapter<T> with(T value)
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 FixedSizeCollection<T>with in interface MutableCollection<T>with in interface MutableList<T>with in class AbstractMutableList<T>Collection.add(Object)public ArrayAdapter<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 FixedSizeCollection<T>without in interface MutableCollection<T>without in interface MutableList<T>without in class AbstractMutableList<T>Collection.remove(Object)public ArrayAdapter<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 FixedSizeCollection<T>withAll in interface MutableCollection<T>withAll in interface MutableList<T>withAll in class AbstractMutableList<T>Collection.addAll(Collection)public ArrayAdapter<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 FixedSizeCollection<T>withoutAll in interface MutableCollection<T>withoutAll in interface MutableList<T>withoutAll in class AbstractMutableList<T>Collection.removeAll(Collection)public ArrayAdapter<T> clone()
clone in interface MutableList<T>clone in class AbstractMutableList<T>public ArrayAdapter<T> sortThis(java.util.Comparator<? super T> comparator)
MutableListsortThis in interface MutableList<T>sortThis in class AbstractMutableList<T>public FixedSizeList<T> tap(Procedure<? super T> procedure)
RichIterablethis.
Example using a Java 8 lambda expression:
RichIterable<Person> tapped =
people.tap(person -> LOGGER.info(person.getName()));
Example using an anonymous inner class:
RichIterable<Person> tapped =
people.tap(new Procedure<Person>()
{
public void value(Person person)
{
LOGGER.info(person.getName());
}
});
tap in interface FixedSizeCollection<T>tap in interface FixedSizeList<T>tap in interface ListIterable<T>tap in interface MutableCollection<T>tap in interface MutableList<T>tap in interface OrderedIterable<T>tap in interface ReversibleIterable<T>tap in interface RichIterable<T>tap in class AbstractMutableList<T>RichIterable.each(Procedure),
InternalIterable.forEach(Procedure)public FixedSizeList<T> toReversed()
MutableListtoReversed in interface FixedSizeList<T>toReversed in interface ListIterable<T>toReversed in interface MutableList<T>toReversed in interface ReversibleIterable<T>toReversed in class AbstractMutableList<T>Copyright © 2004–2018. All rights reserved.