|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.apache.commons.collections4.CollectionUtils
public class CollectionUtils
Provides utility methods and decorators for Collection
instances.
NOTE: From 4.0, method parameters will take Iterable
objects when possible.
Field Summary | |
---|---|
static Collection |
EMPTY_COLLECTION
An empty unmodifiable collection. |
Method Summary | ||
---|---|---|
static
|
addAll(Collection<C> collection,
C[] elements)
Adds all elements in the array to the given collection. |
|
static
|
addAll(Collection<C> collection,
Enumeration<? extends C> enumeration)
Adds all elements in the enumeration to the given collection. |
|
static
|
addAll(Collection<C> collection,
Iterable<? extends C> iterable)
Adds all elements in the Iterable to the given collection. |
|
static
|
addAll(Collection<C> collection,
Iterator<? extends C> iterator)
Adds all elements in the iteration to the given collection. |
|
static
|
addIgnoreNull(Collection<T> collection,
T object)
Adds an element to the collection unless the element is null. |
|
static
|
cardinality(O obj,
Iterable<? super O> coll)
Returns the number of occurrences of obj in coll. |
|
static
|
collate(Iterable<? extends O> a,
Iterable<? extends O> b)
Merges two sorted Collections, a and b, into a single, sorted List such that the natural ordering of the elements is retained. |
|
static
|
collate(Iterable<? extends O> a,
Iterable<? extends O> b,
boolean includeDuplicates)
/** Merges two sorted Collections, a and b, into a single, sorted List such that the natural ordering of the elements is retained. |
|
static
|
collate(Iterable<? extends O> a,
Iterable<? extends O> b,
Comparator<? super O> c)
Merges two sorted Collections, a and b, into a single, sorted List such that the ordering of the elements according to Comparator c is retained. |
|
static
|
collate(Iterable<? extends O> a,
Iterable<? extends O> b,
Comparator<? super O> c,
boolean includeDuplicates)
Merges two sorted Collections, a and b, into a single, sorted List such that the ordering of the elements according to Comparator c is retained. |
|
static
|
collect(Iterable<? extends I> inputCollection,
Transformer<? super I,? extends O> transformer,
R outputCollection)
Transforms all elements from inputCollection with the given transformer and adds them to the outputCollection. |
|
static
|
collect(Iterable<I> inputCollection,
Transformer<? super I,? extends O> transformer)
Returns a new Collection consisting of the elements of inputCollection transformed by the given transformer. |
|
static
|
collect(Iterator<? extends I> inputIterator,
Transformer<? super I,? extends O> transformer,
R outputCollection)
Transforms all elements from the inputIterator with the given transformer and adds them to the outputCollection. |
|
static
|
collect(Iterator<I> inputIterator,
Transformer<? super I,? extends O> transformer)
Transforms all elements from the inputIterator with the given transformer and adds them to the outputCollection. |
|
static boolean |
containsAll(Collection<?> coll1,
Collection<?> coll2)
Returns true iff all elements of coll2 are also contained
in coll1 . |
|
static boolean |
containsAny(Collection<?> coll1,
Collection<?> coll2)
Returns true iff at least one element is in both collections. |
|
static
|
countMatches(Iterable<C> input,
Predicate<? super C> predicate)
Counts the number of elements in the input collection that match the predicate. |
|
static
|
disjunction(Iterable<? extends O> a,
Iterable<? extends O> b)
Returns a Collection containing the exclusive disjunction
(symmetric difference) of the given Iterable s. |
|
static
|
emptyCollection()
Returns the immutable EMPTY_COLLECTION with generic type safety. |
|
static
|
emptyIfNull(Collection<T> collection)
Returns an immutable empty collection if the argument is null ,
or the argument itself otherwise. |
|
static
|
exists(Iterable<C> input,
Predicate<? super C> predicate)
Answers true if a predicate is true for at least one element of a collection. |
|
static
|
extractSingleton(Collection<E> collection)
Extract the lone element of the specified Collection. |
|
static
|
filter(Iterable<T> collection,
Predicate<? super T> predicate)
Filter the collection by applying a Predicate to each element. |
|
static
|
filterInverse(Iterable<T> collection,
Predicate<? super T> predicate)
Filter the collection by applying a Predicate to each element. |
|
static
|
find(Iterable<T> collection,
Predicate<? super T> predicate)
Finds the first element in the given collection which matches the given predicate. |
|
static
|
forAllButLastDo(Iterable<T> collection,
C closure)
Executes the given closure on each but the last element in the collection. |
|
static
|
forAllButLastDo(Iterator<T> iterator,
C closure)
Executes the given closure on each but the last element in the collection. |
|
static
|
forAllDo(Iterable<T> collection,
C closure)
Executes the given closure on each element in the collection. |
|
static
|
forAllDo(Iterator<T> iterator,
C closure)
Executes the given closure on each element in the collection. |
|
static
|
get(Iterable<T> iterable,
int index)
Returns the index -th value in the iterable 's Iterator , throwing
IndexOutOfBoundsException if there is no such element. |
|
static
|
get(Iterator<T> iterator,
int index)
Returns the index -th value in Iterator , throwing
IndexOutOfBoundsException if there is no such element. |
|
static
|
get(Map<K,V> map,
int index)
Returns the index -th Map.Entry in the map 's entrySet ,
throwing IndexOutOfBoundsException if there is no such element. |
|
static Object |
get(Object object,
int index)
Returns the index -th value in object , throwing
IndexOutOfBoundsException if there is no such element or
IllegalArgumentException if object is not an
instance of one of the supported types. |
|
static
|
getCardinalityMap(Iterable<? extends O> coll)
Returns a Map mapping each unique element in the given
Collection to an Integer representing the number
of occurrences of that element in the Collection . |
|
static
|
intersection(Iterable<? extends O> a,
Iterable<? extends O> b)
Returns a Collection containing the intersection of the given
Iterable s. |
|
static boolean |
isEmpty(Collection<?> coll)
Null-safe check if the specified collection is empty. |
|
static boolean |
isEqualCollection(Collection<?> a,
Collection<?> b)
Returns true iff the given Collection s contain
exactly the same elements with exactly the same cardinalities. |
|
static boolean |
isEqualCollection(Collection<?> a,
Collection<?> b,
Equator<?> equator)
Returns true iff the given Collection s contain
exactly the same elements with exactly the same cardinalities. |
|
static boolean |
isFull(Collection<? extends Object> coll)
Returns true if no more elements can be added to the Collection. |
|
static boolean |
isNotEmpty(Collection<?> coll)
Null-safe check if the specified collection is not empty. |
|
static boolean |
isProperSubCollection(Collection<?> a,
Collection<?> b)
Returns true iff a is a proper sub-collection of b, that is, iff the cardinality of e in a is less than or equal to the cardinality of e in b, for each element e in a, and there is at least one element f such that the cardinality of f in b is strictly greater than the cardinality of f in a. |
|
static boolean |
isSubCollection(Collection<?> a,
Collection<?> b)
Returns true iff a is a sub-collection of b, that is, iff the cardinality of e in a is less than or equal to the cardinality of e in b, for each element e in a. |
|
static int |
maxSize(Collection<? extends Object> coll)
Get the maximum number of elements that the Collection can contain. |
|
static
|
permutations(Collection<E> collection)
Returns a Collection of all the permutations of the input collection. |
|
static
|
predicatedCollection(Collection<C> collection,
Predicate<? super C> predicate)
Returns a predicated (validating) collection backed by the given collection. |
|
static
|
removeAll(Collection<E> collection,
Collection<?> remove)
Removes the elements in remove from collection . |
|
static
|
retainAll(Collection<C> collection,
Collection<?> retain)
Returns a collection containing all the elements in collection
that are also in retain . |
|
static void |
reverseArray(Object[] array)
Reverses the order of the given array. |
|
static
|
select(Iterable<? extends O> inputCollection,
Predicate<? super O> predicate)
Selects all elements from input collection which match the given predicate into an output collection. |
|
static
|
select(Iterable<? extends O> inputCollection,
Predicate<? super O> predicate,
R outputCollection)
Selects all elements from input collection which match the given predicate and adds them to outputCollection. |
|
static
|
selectRejected(Iterable<? extends O> inputCollection,
Predicate<? super O> predicate)
Selects all elements from inputCollection which don't match the given predicate into an output collection. |
|
static
|
selectRejected(Iterable<? extends O> inputCollection,
Predicate<? super O> predicate,
R outputCollection)
Selects all elements from inputCollection which don't match the given predicate and adds them to outputCollection. |
|
static int |
size(Object object)
Gets the size of the collection/iterator specified. |
|
static boolean |
sizeIsEmpty(Object object)
Checks if the specified collection/array/iterator is empty. |
|
static
|
subtract(Iterable<? extends O> a,
Iterable<? extends O> b)
Returns a new Collection containing a - b. |
|
static
|
subtract(Iterable<? extends O> a,
Iterable<? extends O> b,
Predicate<O> p)
Returns a new Collection containing a minus a subset of
b. |
|
static
|
synchronizedCollection(Collection<C> collection)
Returns a synchronized collection backed by the given collection. |
|
static
|
transform(Collection<C> collection,
Transformer<? super C,? extends C> transformer)
Transform the collection by applying a Transformer to each element. |
|
static
|
transformingCollection(Collection<E> collection,
Transformer<? super E,? extends E> transformer)
Returns a transformed bag backed by the given collection. |
|
static
|
union(Iterable<? extends O> a,
Iterable<? extends O> b)
Returns a Collection containing the union of the given
Iterable s. |
|
static
|
unmodifiableCollection(Collection<C> collection)
Returns an unmodifiable collection backed by the given collection. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
public static final Collection EMPTY_COLLECTION
Method Detail |
---|
public static <T> Collection<T> emptyCollection()
T
- the element type
EMPTY_COLLECTION
public static <T> Collection<T> emptyIfNull(Collection<T> collection)
null
,
or the argument itself otherwise.
T
- the element typecollection
- the collection, possibly null
null
public static <O> Collection<O> union(Iterable<? extends O> a, Iterable<? extends O> b)
Collection
containing the union of the given
Iterable
s.
The cardinality of each element in the returned Collection
will
be equal to the maximum of the cardinality of that element in the two
given Iterable
s.
O
- the generic type that is able to represent the types contained
in both input collections.a
- the first collection, must not be nullb
- the second collection, must not be null
Collection.addAll(java.util.Collection extends E>)
public static <O> Collection<O> intersection(Iterable<? extends O> a, Iterable<? extends O> b)
Collection
containing the intersection of the given
Iterable
s.
The cardinality of each element in the returned Collection
will
be equal to the minimum of the cardinality of that element in the two
given Iterable
s.
O
- the generic type that is able to represent the types contained
in both input collections.a
- the first collection, must not be nullb
- the second collection, must not be null
Collection.retainAll(java.util.Collection>)
,
containsAny(java.util.Collection>, java.util.Collection>)
public static <O> Collection<O> disjunction(Iterable<? extends O> a, Iterable<? extends O> b)
Collection
containing the exclusive disjunction
(symmetric difference) of the given Iterable
s.
The cardinality of each element e in the returned
Collection
will be equal to
max(cardinality(e,a),cardinality(e,b)) - min(cardinality(e,a),
cardinality(e,b)).
This is equivalent to
subtract
(union(a,b)
,intersection(a,b)
)
or
union
(subtract(a,b)
,subtract(b,a)
).
O
- the generic type that is able to represent the types contained
in both input collections.a
- the first collection, must not be nullb
- the second collection, must not be null
public static <O> Collection<O> subtract(Iterable<? extends O> a, Iterable<? extends O> b)
Collection
containing a - b.
The cardinality of each element e in the returned Collection
will be the cardinality of e in a minus the cardinality
of e in b, or zero, whichever is greater.
O
- the generic type that is able to represent the types contained
in both input collections.a
- the collection to subtract from, must not be nullb
- the collection to subtract, must not be null
Collection.removeAll(java.util.Collection>)
public static <O> Collection<O> subtract(Iterable<? extends O> a, Iterable<? extends O> b, Predicate<O> p)
Collection
containing a minus a subset of
b. Only the elements of b that satisfy the predicate
condition, p are subtracted from a.
The cardinality of each element e in the returned Collection
that satisfies the predicate condition will be the cardinality of e in a
minus the cardinality of e in b, or zero, whichever is greater.
The cardinality of each element e in the returned Collection
that does not
satisfy the predicate condition will be equal to the cardinality of e in a.
O
- the generic type that is able to represent the types contained
in both input collections.a
- the collection to subtract from, must not be nullb
- the collection to subtract, must not be nullp
- the condition used to determine which elements of b are
subtracted.
Collection.removeAll(java.util.Collection>)
public static boolean containsAll(Collection<?> coll1, Collection<?> coll2)
true
iff all elements of coll2
are also contained
in coll1
. The cardinality of values in coll2
is not taken into account,
which is the same behavior as Collection.containsAll(Collection)
.
In other words, this method returns true
iff the
intersection(java.lang.Iterable extends O>, java.lang.Iterable extends O>)
of coll1 and coll2 has the same cardinality as
the set of unique values from coll2
. In case coll2
is empty, true
will be returned.
This method is intended as a replacement for Collection.containsAll(Collection)
with a guaranteed runtime complexity of O(n + m)
. Depending on the type of
Collection
provided, this method will be much faster than calling
Collection.containsAll(Collection)
instead, though this will come at the
cost of an additional space complexity O(n).
coll1
- the first collection, must not be nullcoll2
- the second collection, must not be null
true
iff the intersection of the collections has the same cardinality
as the set of unique elements from the second collectionpublic static boolean containsAny(Collection<?> coll1, Collection<?> coll2)
true
iff at least one element is in both collections.
In other words, this method returns true
iff the
intersection(java.lang.Iterable extends O>, java.lang.Iterable extends O>)
of coll1 and coll2 is not empty.
coll1
- the first collection, must not be nullcoll2
- the second collection, must not be null
true
iff the intersection of the collections is non-emptyintersection(java.lang.Iterable extends O>, java.lang.Iterable extends O>)
public static <O> Map<O,Integer> getCardinalityMap(Iterable<? extends O> coll)
Map
mapping each unique element in the given
Collection
to an Integer
representing the number
of occurrences of that element in the Collection
.
Only those elements present in the collection will appear as keys in the map.
O
- the type of object in the returned Map
. This is a super type of .coll
- the collection to get the cardinality map for, must not be null
public static boolean isSubCollection(Collection<?> a, Collection<?> b)
a
- the first (sub?) collection, must not be nullb
- the second (super?) collection, must not be null
true
iff a is a sub-collection of bisProperSubCollection(java.util.Collection>, java.util.Collection>)
,
Collection.containsAll(java.util.Collection>)
public static boolean isProperSubCollection(Collection<?> a, Collection<?> b)
The implementation assumes
a.size()
and b.size()
represent the
total cardinality of a and b, resp. a.size() < Integer.MAXVALUE
a
- the first (sub?) collection, must not be nullb
- the second (super?) collection, must not be null
true
iff a is a proper sub-collection of bisSubCollection(java.util.Collection>, java.util.Collection>)
,
Collection.containsAll(java.util.Collection>)
public static boolean isEqualCollection(Collection<?> a, Collection<?> b)
Collection
s contain
exactly the same elements with exactly the same cardinalities.
That is, iff the cardinality of e in a is equal to the cardinality of e in b, for each element e in a or b.
a
- the first collection, must not be nullb
- the second collection, must not be null
true
iff the collections contain the same elements with the same cardinalities.public static boolean isEqualCollection(Collection<?> a, Collection<?> b, Equator<?> equator)
Collection
s contain
exactly the same elements with exactly the same cardinalities.
That is, iff the cardinality of e in a is equal to the cardinality of e in b, for each element e in a or b.
a
- the first collection, must not be nullb
- the second collection, must not be nullequator
- the Equator used for testing equality
true
iff the collections contain the same elements with the same cardinalities.
IllegalArgumentException
- if the equator is nullpublic static <O> int cardinality(O obj, Iterable<? super O> coll)
O
- the type of object that the Iterable
may contain.obj
- the object to find the cardinality ofcoll
- the Iterable
to search
public static <T> T find(Iterable<T> collection, Predicate<? super T> predicate)
If the input collection or predicate is null, or no element of the collection matches the predicate, null is returned.
T
- the type of object the Iterable
containscollection
- the collection to search, may be nullpredicate
- the predicate to use, may be null
public static <T,C extends Closure<? super T>> C forAllDo(Iterable<T> collection, C closure)
If the input collection or closure is null, there is no change made.
T
- the type of object the Iterable
containsC
- the closure typecollection
- the collection to get the input from, may be nullclosure
- the closure to perform, may be null
public static <T,C extends Closure<? super T>> C forAllDo(Iterator<T> iterator, C closure)
If the input collection or closure is null, there is no change made.
T
- the type of object the Iterator
containsC
- the closure typeiterator
- the iterator to get the input from, may be nullclosure
- the closure to perform, may be null
public static <T,C extends Closure<? super T>> T forAllButLastDo(Iterable<T> collection, C closure)
If the input collection or closure is null, there is no change made.
T
- the type of object the Iterable
containsC
- the closure typecollection
- the collection to get the input from, may be nullclosure
- the closure to perform, may be null
public static <T,C extends Closure<? super T>> T forAllButLastDo(Iterator<T> iterator, C closure)
If the input collection or closure is null, there is no change made.
T
- the type of object the Collection
containsC
- the closure typeiterator
- the iterator to get the input from, may be nullclosure
- the closure to perform, may be null
public static <T> boolean filter(Iterable<T> collection, Predicate<? super T> predicate)
If the input collection or predicate is null, there is no change made.
T
- the type of object the Iterable
containscollection
- the collection to get the input from, may be nullpredicate
- the predicate to use as a filter, may be null
public static <T> boolean filterInverse(Iterable<T> collection, Predicate<? super T> predicate)
This is equivalent to
filter(collection, PredicateUtils.notPredicate(predicate))if predicate is != null.
If the input collection or predicate is null, there is no change made.
T
- the type of object the Iterable
containscollection
- the collection to get the input from, may be nullpredicate
- the predicate to use as a filter, may be null
public static <C> void transform(Collection<C> collection, Transformer<? super C,? extends C> transformer)
If the input collection or transformer is null, there is no change made.
This routine is best for Lists, for which set() is used to do the transformations "in place." For other Collections, clear() and addAll() are used to replace elements.
If the input collection controls its input, such as a Set, and the Transformer creates duplicates (or are otherwise invalid), the collection may reduce in size due to calling this method.
C
- the type of object the Collection
containscollection
- the Collection
to get the input from, may be nulltransformer
- the transformer to perform, may be nullpublic static <C> int countMatches(Iterable<C> input, Predicate<? super C> predicate)
A null
collection or predicate matches no elements.
C
- the type of object the Iterable
containsinput
- the Iterable
to get the input from, may be nullpredicate
- the predicate to use, may be null
public static <C> boolean exists(Iterable<C> input, Predicate<? super C> predicate)
A null
collection or predicate returns false.
C
- the type of object the Iterable
containsinput
- the Iterable
to get the input from, may be nullpredicate
- the predicate to use, may be null
public static <O> Collection<O> select(Iterable<? extends O> inputCollection, Predicate<? super O> predicate)
A null
predicate matches no elements.
O
- the type of object the Iterable
containsinputCollection
- the collection to get the input from, may not be nullpredicate
- the predicate to use, may be null
NullPointerException
- if the input collection is nullpublic static <O,R extends Collection<? super O>> R select(Iterable<? extends O> inputCollection, Predicate<? super O> predicate, R outputCollection)
If the input collection or predicate is null, there is no change to the output collection.
O
- the type of object the Iterable
containsR
- the type of the output Collection
inputCollection
- the collection to get the input from, may be nullpredicate
- the predicate to use, may be nulloutputCollection
- the collection to output into, may not be null if the inputCollection
and predicate or not null
public static <O> Collection<O> selectRejected(Iterable<? extends O> inputCollection, Predicate<? super O> predicate)
If the input predicate is null
, the result is an empty
list.
O
- the type of object the Iterable
containsinputCollection
- the collection to get the input from, may not be nullpredicate
- the predicate to use, may be null
NullPointerException
- if the input collection is nullpublic static <O,R extends Collection<? super O>> R selectRejected(Iterable<? extends O> inputCollection, Predicate<? super O> predicate, R outputCollection)
If the input predicate is null
, no elements are added to
outputCollection
.
O
- the type of object the Iterable
containsR
- the type of the output Collection
inputCollection
- the collection to get the input from, may be nullpredicate
- the predicate to use, may be nulloutputCollection
- the collection to output into, may not be null if the inputCollection
and predicate or not null
public static <I,O> Collection<O> collect(Iterable<I> inputCollection, Transformer<? super I,? extends O> transformer)
If the input transformer is null, the result is an empty list.
I
- the type of object in the input collectionO
- the type of object in the output collectioninputCollection
- the collection to get the input from, may not be nulltransformer
- the transformer to use, may be null
NullPointerException
- if the input collection is nullpublic static <I,O> Collection<O> collect(Iterator<I> inputIterator, Transformer<? super I,? extends O> transformer)
If the input iterator or transformer is null, the result is an empty list.
I
- the type of object in the input collectionO
- the type of object in the output collectioninputIterator
- the iterator to get the input from, may be nulltransformer
- the transformer to use, may be null
public static <I,O,R extends Collection<? super O>> R collect(Iterable<? extends I> inputCollection, Transformer<? super I,? extends O> transformer, R outputCollection)
If the input collection or transformer is null, there is no change to the output collection.
I
- the type of object in the input collectionO
- the type of object in the output collectionR
- the output type of the transformer - this extends O.inputCollection
- the collection to get the input from, may be nulltransformer
- the transformer to use, may be nulloutputCollection
- the collection to output into, may not be null if the inputCollection
and transformer are not null
NullPointerException
- if the output collection is null and both, inputCollection and
transformer are not nullpublic static <I,O,R extends Collection<? super O>> R collect(Iterator<? extends I> inputIterator, Transformer<? super I,? extends O> transformer, R outputCollection)
If the input iterator or transformer is null, there is no change to the output collection.
I
- the type of object in the input collectionO
- the type of object in the output collectionR
- the output type of the transformer - this extends O.inputIterator
- the iterator to get the input from, may be nulltransformer
- the transformer to use, may be nulloutputCollection
- the collection to output into, may not be null if the inputCollection
and transformer are not null
NullPointerException
- if the output collection is null and both, inputCollection and
transformer are not nullpublic static <T> boolean addIgnoreNull(Collection<T> collection, T object)
T
- the type of object the Collection
containscollection
- the collection to add to, must not be nullobject
- the object to add, if null it will not be added
NullPointerException
- if the collection is nullpublic static <C> boolean addAll(Collection<C> collection, Iterable<? extends C> iterable)
Iterable
to the given collection. If the
Iterable
is a Collection
then it is cast and will be
added using Collection.addAll(Collection)
instead of iterating.
C
- the type of object the Collection
containscollection
- the collection to add to, must not be nulliterable
- the iterable of elements to add, must not be null
NullPointerException
- if the collection or iterator is nullpublic static <C> boolean addAll(Collection<C> collection, Iterator<? extends C> iterator)
C
- the type of object the Collection
containscollection
- the collection to add to, must not be nulliterator
- the iterator of elements to add, must not be null
NullPointerException
- if the collection or iterator is nullpublic static <C> boolean addAll(Collection<C> collection, Enumeration<? extends C> enumeration)
C
- the type of object the Collection
containscollection
- the collection to add to, must not be nullenumeration
- the enumeration of elements to add, must not be null
true
if the collections was changed, false
otherwise
NullPointerException
- if the collection or enumeration is nullpublic static <C> boolean addAll(Collection<C> collection, C[] elements)
C
- the type of object the Collection
containscollection
- the collection to add to, must not be nullelements
- the array of elements to add, must not be null
true
if the collection was changed, false
otherwise
NullPointerException
- if the collection or array is nullpublic static <T> T get(Iterator<T> iterator, int index)
index
-th value in Iterator
, throwing
IndexOutOfBoundsException
if there is no such element.
The Iterator is advanced to index
(or to the end, if
index
exceeds the number of entries) as a side effect of this method.
T
- the type of object in the Iterator
iterator
- the iterator to get a value fromindex
- the index to get
IndexOutOfBoundsException
- if the index is invalid
IllegalArgumentException
- if the object type is invalidpublic static <T> T get(Iterable<T> iterable, int index)
index
-th value in the iterable
's Iterator
, throwing
IndexOutOfBoundsException
if there is no such element.
If the Iterable
is a List
, then it will use List.get(int)
.
T
- the type of object in the Iterable
.iterable
- the Iterable
to get a value fromindex
- the index to get
IndexOutOfBoundsException
- if the index is invalidpublic static Object get(Object object, int index)
index
-th value in object
, throwing
IndexOutOfBoundsException
if there is no such element or
IllegalArgumentException
if object
is not an
instance of one of the supported types.
The supported types, and associated semantics are:
Map.Entry
in position
index
in the map's entrySet
iterator,
if there is such an entry.index
-th array entry is returned,
if there is such an entry; otherwise an IndexOutOfBoundsException
is thrown.index
-th object
returned by the collection's default iterator, if there is such an element.index
-th object in the Iterator/Enumeration, if there
is such an element. The Iterator/Enumeration is advanced to
index
(or to the end, if index
exceeds the
number of entries) as a side effect of this method.
object
- the object to get a value fromindex
- the index to get
IndexOutOfBoundsException
- if the index is invalid
IllegalArgumentException
- if the object type is invalidpublic static <K,V> Map.Entry<K,V> get(Map<K,V> map, int index)
index
-th Map.Entry
in the map
's entrySet
,
throwing IndexOutOfBoundsException
if there is no such element.
K
- the key type in the Map
V
- the key type in the Map
map
- the object to get a value fromindex
- the index to get
IndexOutOfBoundsException
- if the index is invalidpublic static int size(Object object)
This method can handles objects as follows
object
- the object to get the size of, may be null
IllegalArgumentException
- thrown if object is not recognisedpublic static boolean sizeIsEmpty(Object object)
This method can handles objects as follows
Note: This method is named to avoid clashing with
isEmpty(Collection)
.
object
- the object to get the size of, may be null
IllegalArgumentException
- thrown if object is not recognisedpublic static boolean isEmpty(Collection<?> coll)
Null returns true.
coll
- the collection to check, may be null
public static boolean isNotEmpty(Collection<?> coll)
Null returns false.
coll
- the collection to check, may be null
public static void reverseArray(Object[] array)
array
- the array to reversepublic static boolean isFull(Collection<? extends Object> coll)
This method uses the BoundedCollection
interface to determine the
full status. If the collection does not implement this interface then
false is returned.
The collection does not have to implement this interface directly. If the collection has been decorated using the decorators subpackage then these will be removed to access the BoundedCollection.
coll
- the collection to check
NullPointerException
- if the collection is nullpublic static int maxSize(Collection<? extends Object> coll)
This method uses the BoundedCollection
interface to determine the
maximum size. If the collection does not implement this interface then
-1 is returned.
The collection does not have to implement this interface directly. If the collection has been decorated using the decorators subpackage then these will be removed to access the BoundedCollection.
coll
- the collection to check
NullPointerException
- if the collection is nullpublic static <O extends Comparable<? super O>> List<O> collate(Iterable<? extends O> a, Iterable<? extends O> b)
Uses the standard O(n) merge algorithm for combining two sorted lists.
O
- the element typea
- the first collection, must not be nullb
- the second collection, must not be null
IllegalArgumentException
- if either collection is nullpublic static <O extends Comparable<? super O>> List<O> collate(Iterable<? extends O> a, Iterable<? extends O> b, boolean includeDuplicates)
Uses the standard O(n) merge algorithm for combining two sorted lists.
O
- the element typea
- the first collection, must not be nullb
- the second collection, must not be nullincludeDuplicates
- if true
duplicate elements will be retained, otherwise
they will be removed in the output collection
IllegalArgumentException
- if either collection is nullpublic static <O> List<O> collate(Iterable<? extends O> a, Iterable<? extends O> b, Comparator<? super O> c)
Uses the standard O(n) merge algorithm for combining two sorted lists.
O
- the element typea
- the first collection, must not be nullb
- the second collection, must not be nullc
- the comparator to use for the merge.
IllegalArgumentException
- if either collection or the comparator is nullpublic static <O> List<O> collate(Iterable<? extends O> a, Iterable<? extends O> b, Comparator<? super O> c, boolean includeDuplicates)
Uses the standard O(n) merge algorithm for combining two sorted lists.
O
- the element typea
- the first collection, must not be nullb
- the second collection, must not be nullc
- the comparator to use for the merge.includeDuplicates
- if true
duplicate elements will be retained, otherwise
they will be removed in the output collection
IllegalArgumentException
- if either collection or the comparator is nullpublic static <E> Collection<List<E>> permutations(Collection<E> collection)
Collection
of all the permutations of the input collection.
NOTE: the number of permutations of a given collection is equal to n!, where n is the size of the collection. Thus, the resulting collection will become very large for collections > 10 (e.g. 10! = 3628800, 15! = 1307674368000).
For larger collections it is advised to use a PermutationIterator
to
iterate over all permutations.
E
- the element typecollection
- the collection to create permutations for, may not be null
NullPointerException
- if collection is nullPermutationIterator
public static <C> Collection<C> retainAll(Collection<C> collection, Collection<?> retain)
collection
that are also in retain
. The cardinality of an element e
in the returned collection is the same as the cardinality of e
in collection
unless retain
does not contain e
, in which
case the cardinality is zero. This method is useful if you do not wish to modify
the collection c
and thus cannot call c.retainAll(retain);
.
C
- the type of object the Collection
containscollection
- the collection whose contents are the target of the #retailAll operationretain
- the collection containing the elements to be retained in the returned collection
Collection
containing all the elements of collection
that occur at least once in retain
.
NullPointerException
- if either parameter is nullpublic static <E> Collection<E> removeAll(Collection<E> collection, Collection<?> remove)
remove
from collection
. That is, this
method returns a collection containing all the elements in c
that are not in remove
. The cardinality of an element e
in the returned collection is the same as the cardinality of e
in collection
unless remove
contains e
, in which
case the cardinality is zero. This method is useful if you do not wish to modify
the collection c
and thus cannot call collection.removeAll(remove);
.
E
- the type of object the Collection
containscollection
- the collection from which items are removed (in the returned collection)remove
- the items to be removed from the returned collection
Collection
containing all the elements of collection
except
any elements that also occur in remove
.
NullPointerException
- if either parameter is nullpublic static <C> Collection<C> synchronizedCollection(Collection<C> collection)
You must manually synchronize on the returned buffer's iterator to avoid non-deterministic behavior:
Collection c = CollectionUtils.synchronizedCollection(myCollection); synchronized (c) { Iterator i = c.iterator(); while (i.hasNext()) { process (i.next()); } }This method uses the implementation in the decorators subpackage.
C
- the type of object the Collection
containscollection
- the collection to synchronize, must not be null
IllegalArgumentException
- if the collection is nullpublic static <C> Collection<C> unmodifiableCollection(Collection<C> collection)
This method uses the implementation in the decorators subpackage.
C
- the type of object the Collection
containscollection
- the collection to make unmodifiable, must not be null
IllegalArgumentException
- if the collection is nullpublic static <C> Collection<C> predicatedCollection(Collection<C> collection, Predicate<? super C> predicate)
Only objects that pass the test in the given predicate can be added to the collection. Trying to add an invalid object results in an IllegalArgumentException. It is important not to use the original collection after invoking this method, as it is a backdoor for adding invalid objects.
C
- the type of objects in the Collection.collection
- the collection to predicate, must not be nullpredicate
- the predicate for the collection, must not be null
IllegalArgumentException
- if the Collection is nullpublic static <E> Collection<E> transformingCollection(Collection<E> collection, Transformer<? super E,? extends E> transformer)
Each object is passed through the transformer as it is added to the Collection. It is important not to use the original collection after invoking this method, as it is a backdoor for adding untransformed objects.
Existing entries in the specified collection will not be transformed.
If you want that behaviour, see TransformedCollection.transformedCollection(java.util.Collection
.
E
- the type of object the Collection
containscollection
- the collection to predicate, must not be nulltransformer
- the transformer for the collection, must not be null
IllegalArgumentException
- if the Collection or Transformer is nullpublic static <E> E extractSingleton(Collection<E> collection)
E
- collection typecollection
- to read
IllegalArgumentException
- if collection is null/empty or contains more than one element
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |