com.helger.commons.collection

Class CollectionHelper

java.lang.Object

com.helger.commons.collection.CollectionHelper

@Immutable
public final class CollectionHelper
extends Object

Provides various helper methods to handle collections like List, Set and Map.

Author:

Philip Helger

Method Summary

Modifier and Type	Method and Description
static <ELEMENTTYPE> boolean	contains(Collection<? extends ELEMENTTYPE> aCollection, ELEMENTTYPE aSearch)
static <ELEMENTTYPE> boolean	containsAny(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static boolean	containsAnyNullElement(Iterable<?> aCont) Check if the passed collection contains at least one null element.
static <ELEMENTTYPE> boolean	containsNone(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static <ELEMENTTYPE> boolean	containsOnly(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter) Check if the passed collection contains only elements matching the predicate.
static boolean	containsOnlyNullElements(Iterable<?> aCont) Check if the passed collection contains only null element.
static <ELEMENTTYPE> void	findAll(Iterable<? extends ELEMENTTYPE> aSrc, Predicate<? super ELEMENTTYPE> aFilter, Collection<? super ELEMENTTYPE> aDst)
static <ELEMENTTYPE> void	findAll(Iterable<? extends ELEMENTTYPE> aSrc, Predicate<? super ELEMENTTYPE> aFilter, Consumer<? super ELEMENTTYPE> aConsumer)
static <SRCTYPE,DSTTYPE> void	findAllMapped(Iterable<? extends SRCTYPE> aSrc, Function<? super SRCTYPE,? extends DSTTYPE> aMapper, Collection<? super DSTTYPE> aDst)
static <SRCTYPE,DSTTYPE> void	findAllMapped(Iterable<? extends SRCTYPE> aSrc, Function<? super SRCTYPE,? extends DSTTYPE> aMapper, Consumer<? super DSTTYPE> aConsumer)
static <SRCTYPE,DSTTYPE> void	findAllMapped(Iterable<? extends SRCTYPE> aSrc, Predicate<? super SRCTYPE> aFilter, Function<? super SRCTYPE,? extends DSTTYPE> aMapper, Collection<? super DSTTYPE> aDst)
static <SRCTYPE,DSTTYPE> void	findAllMapped(Iterable<? extends SRCTYPE> aSrc, Predicate<? super SRCTYPE> aFilter, Function<? super SRCTYPE,? extends DSTTYPE> aMapper, Consumer<? super DSTTYPE> aConsumer)
static <ELEMENTTYPE> ELEMENTTYPE	findFirst(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static <ELEMENTTYPE> ELEMENTTYPE	findFirst(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter, ELEMENTTYPE aDefault)
static <ELEMENTTYPE,DSTTYPE> DSTTYPE	findFirstMapped(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter, Function<? super ELEMENTTYPE,DSTTYPE> aMapper)
static <ELEMENTTYPE,DSTTYPE> DSTTYPE	findFirstMapped(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter, Function<? super ELEMENTTYPE,DSTTYPE> aMapper, DSTTYPE aDefault)
static CommonsArrayList<?>	getAsList(Object aObj) Get the passed object as a CommonsArrayList object.
static <ELEMENTTYPE> ELEMENTTYPE	getAtIndex(Iterable<? extends ELEMENTTYPE> aCollection, int nIndex)
static <ELEMENTTYPE> ELEMENTTYPE	getAtIndex(Iterable<? extends ELEMENTTYPE> aCollection, int nIndex, ELEMENTTYPE aDefault)
static <ELEMENTTYPE> ELEMENTTYPE	getAtIndex(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter, int nIndex)
static <ELEMENTTYPE> ELEMENTTYPE	getAtIndex(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter, int nIndex, ELEMENTTYPE aDefault)
static <ELEMENTTYPE> ELEMENTTYPE	getAtIndex(List<? extends ELEMENTTYPE> aList, int nIndex) Safe list element accessor method.
static <ELEMENTTYPE> ELEMENTTYPE	getAtIndex(List<? extends ELEMENTTYPE> aList, int nIndex, ELEMENTTYPE aDefault) Safe list element accessor method.
static <SRCTYPE,DSTTYPE> DSTTYPE	getAtIndexMapped(Iterable<? extends SRCTYPE> aCollection, Predicate<? super SRCTYPE> aFilter, int nIndex, Function<? super SRCTYPE,? extends DSTTYPE> aMapper)
static <SRCTYPE,DSTTYPE> DSTTYPE	getAtIndexMapped(Iterable<? extends SRCTYPE> aCollection, Predicate<? super SRCTYPE> aFilter, int nIndex, Function<? super SRCTYPE,? extends DSTTYPE> aMapper, DSTTYPE aDefault)
static ECollectionBaseType	getCollectionBaseTypeOfClass(Class<?> aClass)
static ECollectionBaseType	getCollectionBaseTypeOfObject(Object aObj)
static <KEY,VALUE> ICommonsMap<KEY,VALUE>	getCombinedMap(Map<KEY,VALUE> aMap1, Map<KEY,VALUE> aMap2) Create a map that contains the combination of the other 2 maps.
static <ELEMENTTYPE,COLLTYPE extends Collection<? super ELEMENTTYPE>> COLLTYPE	getConcatenatedInline(COLLTYPE aCont, Collection<? extends ELEMENTTYPE> aElementsToAdd)
static <ELEMENTTYPE,COLLTYPE extends Collection<? super ELEMENTTYPE>> COLLTYPE	getConcatenatedInline(COLLTYPE aCont, ELEMENTTYPE... aElementsToAdd)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getConcatenatedList(Collection<? extends ELEMENTTYPE> aCollection1, Collection<? extends ELEMENTTYPE> aCollection2)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getConcatenatedList(Collection<? extends ELEMENTTYPE> aCont1, ELEMENTTYPE... aCont2)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getConcatenatedList(ELEMENTTYPE[] aCont1, Collection<? extends ELEMENTTYPE> aCont2)
static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE>	getConcatenatedSet(Collection<? extends ELEMENTTYPE> aCont1, Collection<? extends ELEMENTTYPE> aCont2)
static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE>	getConcatenatedSet(Collection<? extends ELEMENTTYPE> aCont1, ELEMENTTYPE... aCont2)
static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE>	getConcatenatedSet(ELEMENTTYPE[] aCont1, Collection<? extends ELEMENTTYPE> aCont2)
static <ELEMENTTYPE> int	getCount(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE>	getDifference(Collection<? extends ELEMENTTYPE> aCollection1, Collection<? extends ELEMENTTYPE> aCollection2) Get all elements that are only contained in the first contained, and not in the second.
static <KEY,VALUE> ICommonsMap<KEY,VALUE>	getFilteredMap(ICommonsMap<KEY,VALUE> aValues, Collection<? extends KEY> aKeys) Get a map consisting only of a set of specified keys.
static <ELEMENTTYPE> ELEMENTTYPE	getFirstElement(Collection<ELEMENTTYPE> aCollection) Get the first element of the passed collection.
static <ELEMENTTYPE> ELEMENTTYPE	getFirstElement(Iterable<ELEMENTTYPE> aIterable) Get the first element of the passed iterable.
static <ELEMENTTYPE> ELEMENTTYPE	getFirstElement(List<ELEMENTTYPE> aList) Get the first element of the passed list.
static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE>	getIntersected(Collection<? extends ELEMENTTYPE> aCollection1, Collection<? extends ELEMENTTYPE> aCollection2) Get all elements that are contained in the first AND in the second container.
static <ELEMENTTYPE> ELEMENTTYPE	getLastElement(Collection<ELEMENTTYPE> aCollection)
static <ELEMENTTYPE> ELEMENTTYPE	getLastElement(Iterable<ELEMENTTYPE> aIterable)
static <ELEMENTTYPE> ELEMENTTYPE	getLastElement(List<ELEMENTTYPE> aList)
static <ELEMENTTYPE> List<ELEMENTTYPE>	getNotNull(List<ELEMENTTYPE> aList)
static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>	getNotNull(Map<KEYTYPE,VALUETYPE> aMap)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> NavigableMap<KEYTYPE,VALUETYPE>	getNotNull(NavigableMap<KEYTYPE,VALUETYPE> aNavigableMap)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> NavigableSet<ELEMENTTYPE>	getNotNull(NavigableSet<ELEMENTTYPE> aNavigableSet)
static <ELEMENTTYPE> Set<ELEMENTTYPE>	getNotNull(Set<ELEMENTTYPE> aSet)
static <ELEMENTTYPE,LISTTYPE extends List<ELEMENTTYPE>> LISTTYPE	getReverseInlineList(LISTTYPE aList)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getReverseList(Collection<? extends ELEMENTTYPE> aCollection)
static int	getSize(Collection<?> aCollection) Retrieve the size of the passed Collection.
static int	getSize(Iterable<?> aIterable) Retrieve the size of the passed Iterable.
static int	getSize(Map<?,?> aMap) Retrieve the size of the passed Map.
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE>	getSorted(Collection<? extends ELEMENTTYPE> aCont) Convert the given collection object to a sorted list.
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getSorted(Collection<? extends ELEMENTTYPE> aCont, Comparator<? super ELEMENTTYPE> aComparator) Convert the given collection object to a sorted list.
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE>	getSorted(ELEMENTTYPE... aCont) Convert the given iterable object to a sorted list.
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getSorted(ELEMENTTYPE[] aCont, Comparator<? super ELEMENTTYPE> aComparator) Convert the given iterable object to a sorted list.
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE>	getSorted(IIterableIterator<? extends ELEMENTTYPE> aIter) Convert the given iterator to a sorted list.
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE>	getSorted(IIterableIterator<? extends ELEMENTTYPE> aIter, Comparator<? super ELEMENTTYPE> aComparator) Convert the given iterator to a sorted list.
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE>	getSorted(Iterable<? extends ELEMENTTYPE> aCont) Convert the given iterable object to a sorted list.
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getSorted(Iterable<? extends ELEMENTTYPE> aCont, Comparator<? super ELEMENTTYPE> aComparator) Convert the given iterable object to a sorted list.
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE>	getSorted(Iterator<? extends ELEMENTTYPE> aIter) Convert the given iterator to a sorted list.
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getSorted(Iterator<? extends ELEMENTTYPE> aIter, Comparator<? super ELEMENTTYPE> aComparator) Convert the given iterator to a sorted list.
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> ICommonsMap<KEYTYPE,VALUETYPE>	getSortedByKey(Map<KEYTYPE,VALUETYPE> aMap) Get a map sorted by aIter's keys.
static <KEYTYPE,VALUETYPE> ICommonsMap<KEYTYPE,VALUETYPE>	getSortedByKey(Map<KEYTYPE,VALUETYPE> aMap, Comparator<? super KEYTYPE> aKeyComparator) Get a map sorted by its keys.
static <KEYTYPE,VALUETYPE extends Comparable<? super VALUETYPE>> ICommonsMap<KEYTYPE,VALUETYPE>	getSortedByValue(Map<KEYTYPE,VALUETYPE> aMap) Get a map sorted by its values.
static <KEYTYPE,VALUETYPE> ICommonsMap<KEYTYPE,VALUETYPE>	getSortedByValue(Map<KEYTYPE,VALUETYPE> aMap, Comparator<? super VALUETYPE> aValueComparator) Get a map sorted by aIter's values.
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>,LISTTYPE extends List<ELEMENTTYPE>> LISTTYPE	getSortedInline(LISTTYPE aList)
static <ELEMENTTYPE,LISTTYPE extends List<ELEMENTTYPE>> LISTTYPE	getSortedInline(LISTTYPE aList, Comparator<? super ELEMENTTYPE> aComparator)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	getSubList(List<ELEMENTTYPE> aCont, int nStartIndex, int nSectionLength) Gets a sublist excerpt of the passed list.
static boolean	isCollectionClass(Class<?> aClass)
static boolean	isCollectionObject(Object aObj)
static boolean	isEmpty(Collection<?> aCont)
static boolean	isEmpty(Iterable<?> aCont)
static boolean	isEmpty(Map<?,?> aCont)
static boolean	isNotEmpty(Collection<?> aCont)
static boolean	isNotEmpty(Iterable<?> aCont)
static boolean	isNotEmpty(Map<?,?> aCont)
static <ELEMENTTYPE> Collection<ELEMENTTYPE>	makeUnmodifiable(Collection<ELEMENTTYPE> aCollection)
static <ELEMENTTYPE> List<ELEMENTTYPE>	makeUnmodifiable(ELEMENTTYPE... aArray)
static <ELEMENTTYPE> List<ELEMENTTYPE>	makeUnmodifiable(List<ELEMENTTYPE> aList)
static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>	makeUnmodifiable(Map<KEYTYPE,VALUETYPE> aMap)
static <KEYTYPE,VALUETYPE> NavigableMap<KEYTYPE,VALUETYPE>	makeUnmodifiable(NavigableMap<KEYTYPE,VALUETYPE> aNavigableMap)
static <ELEMENTTYPE> NavigableSet<ELEMENTTYPE>	makeUnmodifiable(NavigableSet<ELEMENTTYPE> aNavigableSet)
static <ELEMENTTYPE> Set<ELEMENTTYPE>	makeUnmodifiable(Set<ELEMENTTYPE> aSet)
static <ELEMENTTYPE> Collection<ELEMENTTYPE>	makeUnmodifiableNotNull(Collection<ELEMENTTYPE> aCollection)
static <ELEMENTTYPE> List<ELEMENTTYPE>	makeUnmodifiableNotNull(List<ELEMENTTYPE> aList)
static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>	makeUnmodifiableNotNull(Map<KEYTYPE,VALUETYPE> aMap)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> NavigableMap<KEYTYPE,VALUETYPE>	makeUnmodifiableNotNull(NavigableMap<KEYTYPE,VALUETYPE> aNavigableMap)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> NavigableSet<ELEMENTTYPE>	makeUnmodifiableNotNull(NavigableSet<ELEMENTTYPE> aNavigableSet)
static <ELEMENTTYPE> Set<ELEMENTTYPE>	makeUnmodifiableNotNull(Set<ELEMENTTYPE> aSet)
static <ELEMENTTYPE extends Enum<ELEMENTTYPE>> EnumSet<ELEMENTTYPE>	newEnumSet(Class<ELEMENTTYPE> aEnumClass, Collection<ELEMENTTYPE> aValues)
static <ELEMENTTYPE extends Enum<ELEMENTTYPE>> EnumSet<ELEMENTTYPE>	newEnumSet(Class<ELEMENTTYPE> aEnumClass, ELEMENTTYPE... aValues)
static <ELEMENTTYPE extends Enum<ELEMENTTYPE>> EnumSet<ELEMENTTYPE>	newEnumSet(Class<ELEMENTTYPE> aEnumClass, EnumSet<ELEMENTTYPE> aValues)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList()
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(Collection<? extends ELEMENTTYPE> aCont)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(Collection<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(ELEMENTTYPE... aValues)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(ELEMENTTYPE aValue)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(Enumeration<? extends ELEMENTTYPE> aEnum) Compared to Collections.list(Enumeration) this method is more flexible in Generics parameter.
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(IIterableIterator<? extends ELEMENTTYPE> aIter)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(int nInitialCapacity)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(Iterable<? extends ELEMENTTYPE> aIter)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newList(Iterator<? extends ELEMENTTYPE> aIter)
static <SRCTYPE,DSTTYPE> CommonsArrayList<DSTTYPE>	newListMapped(Collection<? extends SRCTYPE> aCollection, Function<? super SRCTYPE,? extends DSTTYPE> aMapper)
static <ELEMENTTYPE,DSTTYPE> CommonsArrayList<DSTTYPE>	newListMapped(Iterable<? extends ELEMENTTYPE> aIter, Function<? super ELEMENTTYPE,? extends DSTTYPE> aMapper)
static <ELEMENTTYPE,DSTTYPE> CommonsArrayList<DSTTYPE>	newListMapped(Iterable<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter, Function<? super ELEMENTTYPE,? extends DSTTYPE> aMapper)
static <SRCTYPE,DSTTYPE> CommonsArrayList<DSTTYPE>	newListMapped(SRCTYPE[] aValues, Function<? super SRCTYPE,? extends DSTTYPE> aMapper)
static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE>	newListPrefilled(ELEMENTTYPE aValue, int nElements)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap()
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)
static <ELEMENTTYPE> CommonsHashMap<ELEMENTTYPE,ELEMENTTYPE>	newMap(ELEMENTTYPE... aValues)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(int nInitialCapacity)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(KEYTYPE[] aKeys, VALUETYPE[] aValues)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(KEYTYPE aKey, VALUETYPE aValue)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)
static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE>	newMap(Map<KEYTYPE,VALUETYPE> aMap, Predicate<Map.Entry<? super KEYTYPE,? super VALUETYPE>> aFilter)
static <SRCTYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsHashMap<DSTKEYTYPE,DSTVALUETYPE>	newMapMapped(Collection<? extends SRCTYPE> aCollection, Function<? super SRCTYPE,? extends DSTKEYTYPE> aKeyMapper, Function<? super SRCTYPE,? extends DSTVALUETYPE> aValueMapper)
static <SRCKEYTYPE,SRCVALUETYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsHashMap<DSTKEYTYPE,DSTVALUETYPE>	newMapMapped(Map<? extends SRCKEYTYPE,? extends SRCVALUETYPE> aMap, Function<? super SRCKEYTYPE,? extends DSTKEYTYPE> aKeyMapper, Function<? super SRCVALUETYPE,? extends DSTVALUETYPE> aValueMapper)
static CommonsArrayList<?>	newObjectListFromArray(Object aValue, Class<?> aComponentType)
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap()
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)
static <ELEMENTTYPE> CommonsLinkedHashMap<ELEMENTTYPE,ELEMENTTYPE>	newOrderedMap(ELEMENTTYPE... aValues)
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(int nInitialCapacity)
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(KEYTYPE[] aKeys, VALUETYPE[] aValues) Retrieve a map that is ordered in the way the parameter arrays are passed in.
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(KEYTYPE aKey, VALUETYPE aValue)
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)
static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE>	newOrderedMap(Map<KEYTYPE,VALUETYPE> aMap, Predicate<Map.Entry<? super KEYTYPE,? super VALUETYPE>> aFilter)
static <SRCTYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsLinkedHashMap<DSTKEYTYPE,DSTVALUETYPE>	newOrderedMapMapped(Collection<? extends SRCTYPE> aCollection, Function<? super SRCTYPE,? extends DSTKEYTYPE> aKeyMapper, Function<? super SRCTYPE,? extends DSTVALUETYPE> aValueMapper)
static <SRCKEYTYPE,SRCVALUETYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsLinkedHashMap<DSTKEYTYPE,DSTVALUETYPE>	newOrderedMapMapped(Map<? extends SRCKEYTYPE,? extends SRCVALUETYPE> aMap, Function<? super SRCKEYTYPE,? extends DSTKEYTYPE> aKeyMapper, Function<? super SRCVALUETYPE,? extends DSTVALUETYPE> aValueMapper)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet()
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(Collection<? extends ELEMENTTYPE> aCont)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(Collection<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(ELEMENTTYPE... aValues)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(ELEMENTTYPE aValue)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(Enumeration<? extends ELEMENTTYPE> aEnum)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(IIterableIterator<? extends ELEMENTTYPE> aIter)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(int nInitialCapacity)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(Iterable<? extends ELEMENTTYPE> aCont)
static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE>	newOrderedSet(Iterator<? extends ELEMENTTYPE> aIter)
static <SRCTYPE,DSTTYPE> CommonsLinkedHashSet<DSTTYPE>	newOrderedSetMapped(Collection<? extends SRCTYPE> aCollection, Function<? super SRCTYPE,DSTTYPE> aMapper)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet()
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(Collection<? extends ELEMENTTYPE> aCont)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(Collection<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(ELEMENTTYPE... aValues)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(ELEMENTTYPE aValue)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(Enumeration<? extends ELEMENTTYPE> aEnum)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(IIterableIterator<? extends ELEMENTTYPE> aIter)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(int nInitialCapacity)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(Iterable<? extends ELEMENTTYPE> aCont)
static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE>	newSet(Iterator<? extends ELEMENTTYPE> aIter)
static <SRCTYPE,DSTTYPE> CommonsHashSet<DSTTYPE>	newSetMapped(Collection<? extends SRCTYPE> aCollection, Function<? super SRCTYPE,DSTTYPE> aMapper)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap()
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeMap<ELEMENTTYPE,ELEMENTTYPE>	newSortedMap(ELEMENTTYPE... aValues)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap(KEYTYPE[] aKeys, VALUETYPE[] aValues)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap(KEYTYPE aKey, VALUETYPE aValue)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)
static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE>	newSortedMap(Map<KEYTYPE,VALUETYPE> aMap, Predicate<Map.Entry<? super KEYTYPE,? super VALUETYPE>> aFilter)
static <SRCKEYTYPE,SRCVALUETYPE,DSTKEYTYPE extends Comparable<? super DSTKEYTYPE>,DSTVALUETYPE> CommonsTreeMap<DSTKEYTYPE,DSTVALUETYPE>	newSortedMapMapped(Map<? extends SRCKEYTYPE,? extends SRCVALUETYPE> aMap, Function<? super SRCKEYTYPE,DSTKEYTYPE> aKeyMapper, Function<? super SRCVALUETYPE,DSTVALUETYPE> aValueMapper)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet()
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(Collection<? extends ELEMENTTYPE> aCont)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(Collection<? extends ELEMENTTYPE> aCollection, Predicate<? super ELEMENTTYPE> aFilter)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(ELEMENTTYPE... aValues)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(ELEMENTTYPE aValue)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(Enumeration<? extends ELEMENTTYPE> aEnum)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(IIterableIterator<? extends ELEMENTTYPE> aIter)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(Iterable<? extends ELEMENTTYPE> aCont)
static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE>	newSortedSet(Iterator<? extends ELEMENTTYPE> aIter)
static <SRCTYPE,DSTTYPE extends Comparable<? super DSTTYPE>> CommonsTreeSet<DSTTYPE>	newSortedSetMapped(Collection<? extends SRCTYPE> aCollection, Function<? super SRCTYPE,DSTTYPE> aMapper)
static <ELEMENTTYPE> ELEMENTTYPE	removeAndReturnElementAtIndex(List<ELEMENTTYPE> aList, int nIndex) Remove the element at the specified index from the passed list.
static EChange	removeAtIndex(List<?> aList, int nIndex) Remove the element at the specified index from the passed list.
static <ELEMENTTYPE> ELEMENTTYPE	removeFirstElement(List<ELEMENTTYPE> aList)
static <ELEMENTTYPE> ELEMENTTYPE	removeLastElement(List<ELEMENTTYPE> aList)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getCollectionBaseTypeOfClass

@Nullable
public static ECollectionBaseType getCollectionBaseTypeOfClass(@Nullable
                                                                          Class<?> aClass)

getCollectionBaseTypeOfObject

@Nullable
public static ECollectionBaseType getCollectionBaseTypeOfObject(@Nullable
                                                                           Object aObj)

isCollectionClass

public static boolean isCollectionClass(@Nullable
                                        Class<?> aClass)

isCollectionObject

public static boolean isCollectionObject(@Nullable
                                         Object aObj)

getAsList

@Nonnull
public static CommonsArrayList<?> getAsList(@Nonnull
                                                      Object aObj)

Get the passed object as a CommonsArrayList object. This is helpful in case you want to compare the String array ["a", "b"] with the List<String> ("a", "b") If the passed object is not a recognized. container type, than a new list with one element is created!

Parameters:

aObj - The object to be converted. May not be null.

Returns:

The object as a collection. Never null.

getNotNull

@Nonnull
public static <ELEMENTTYPE> List<ELEMENTTYPE> getNotNull(@Nullable
                                                                   List<ELEMENTTYPE> aList)

getNotNull

@Nonnull
public static <ELEMENTTYPE> Set<ELEMENTTYPE> getNotNull(@Nullable
                                                                  Set<ELEMENTTYPE> aSet)

getNotNull

@Nonnull
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> getNotNull(@Nullable
                                                                              Map<KEYTYPE,VALUETYPE> aMap)

getNotNull

@Nonnull
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> NavigableSet<ELEMENTTYPE> getNotNull(@Nullable
                                                                                                                   NavigableSet<ELEMENTTYPE> aNavigableSet)

getNotNull

@Nonnull
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> NavigableMap<KEYTYPE,VALUETYPE> getNotNull(@Nullable
                                                                                                                           NavigableMap<KEYTYPE,VALUETYPE> aNavigableMap)

makeUnmodifiable

@SafeVarargs
 @Nullable
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> makeUnmodifiable(@Nullable
                                                                                                                   ELEMENTTYPE... aArray)

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Collection<ELEMENTTYPE> makeUnmodifiable(@Nullable
                                                                                                          Collection<ELEMENTTYPE> aCollection)

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> makeUnmodifiable(@Nullable
                                                                                                    List<ELEMENTTYPE> aList)

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> makeUnmodifiable(@Nullable
                                                                                                   Set<ELEMENTTYPE> aSet)

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> makeUnmodifiable(@Nullable
                                                                                                               Map<KEYTYPE,VALUETYPE> aMap)

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <ELEMENTTYPE> NavigableSet<ELEMENTTYPE> makeUnmodifiable(@Nullable
                                                                                                            NavigableSet<ELEMENTTYPE> aNavigableSet)

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> NavigableMap<KEYTYPE,VALUETYPE> makeUnmodifiable(@Nullable
                                                                                                                        NavigableMap<KEYTYPE,VALUETYPE> aNavigableMap)

makeUnmodifiableNotNull

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Collection<ELEMENTTYPE> makeUnmodifiableNotNull(@Nullable
                                                                                                                Collection<ELEMENTTYPE> aCollection)

makeUnmodifiableNotNull

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> makeUnmodifiableNotNull(@Nullable
                                                                                                          List<ELEMENTTYPE> aList)

makeUnmodifiableNotNull

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> makeUnmodifiableNotNull(@Nullable
                                                                                                         Set<ELEMENTTYPE> aSet)

makeUnmodifiableNotNull

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> makeUnmodifiableNotNull(@Nullable
                                                                                                                     Map<KEYTYPE,VALUETYPE> aMap)

makeUnmodifiableNotNull

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> NavigableSet<ELEMENTTYPE> makeUnmodifiableNotNull(@Nullable
                                                                                                                                                          NavigableSet<ELEMENTTYPE> aNavigableSet)

makeUnmodifiableNotNull

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> NavigableMap<KEYTYPE,VALUETYPE> makeUnmodifiableNotNull(@Nullable
                                                                                                                                                                  NavigableMap<KEYTYPE,VALUETYPE> aNavigableMap)

getDifference

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE> getDifference(@Nullable
                                                                                                    Collection<? extends ELEMENTTYPE> aCollection1,
                                                                                                    @Nullable
                                                                                                    Collection<? extends ELEMENTTYPE> aCollection2)

Get all elements that are only contained in the first contained, and not in the second. This method implements aCont1 - aCont2.

Type Parameters:

ELEMENTTYPE - Set element type

Parameters:

aCollection1 - The first container. May be null or empty.

aCollection2 - The second container. May be null or empty.

Returns:

The difference and never null. Returns an empty set, if the first container is empty. Returns a copy of the first container, if the second container is empty. Returns aCont1 - aCont2 if both containers are non-empty.

getIntersected

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE> getIntersected(@Nullable
                                                                                                     Collection<? extends ELEMENTTYPE> aCollection1,
                                                                                                     @Nullable
                                                                                                     Collection<? extends ELEMENTTYPE> aCollection2)

Get all elements that are contained in the first AND in the second container.

Type Parameters:

ELEMENTTYPE - Collection element type

Parameters:

aCollection1 - The first container. May be null or empty.

aCollection2 - The second container. May be null or empty.

Returns:

An empty set, if either the first or the second container are empty. Returns a set of elements that are contained in both containers, if both containers are non-empty. The return value is never null.

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nonnegative
                                                                                                           int nInitialCapacity)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap()

newMapMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCKEYTYPE,SRCVALUETYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsHashMap<DSTKEYTYPE,DSTVALUETYPE> newMapMapped(@Nullable
                                                                                                                                                     Map<? extends SRCKEYTYPE,? extends SRCVALUETYPE> aMap,
                                                                                                                                                     @Nonnull
                                                                                                                                                     Function<? super SRCKEYTYPE,? extends DSTKEYTYPE> aKeyMapper,
                                                                                                                                                     @Nonnull
                                                                                                                                                     Function<? super SRCVALUETYPE,? extends DSTVALUETYPE> aValueMapper)

newMapMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCTYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsHashMap<DSTKEYTYPE,DSTVALUETYPE> newMapMapped(@Nullable
                                                                                                                                     Collection<? extends SRCTYPE> aCollection,
                                                                                                                                     @Nonnull
                                                                                                                                     Function<? super SRCTYPE,? extends DSTKEYTYPE> aKeyMapper,
                                                                                                                                     @Nonnull
                                                                                                                                     Function<? super SRCTYPE,? extends DSTVALUETYPE> aValueMapper)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nullable
                                                                                                           Map<KEYTYPE,VALUETYPE> aMap,
                                                                                                           @Nonnull
                                                                                                           Predicate<Map.Entry<? super KEYTYPE,? super VALUETYPE>> aFilter)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nullable
                                                                                                           KEYTYPE aKey,
                                                                                                           @Nullable
                                                                                                           VALUETYPE aValue)

newMap

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE> CommonsHashMap<ELEMENTTYPE,ELEMENTTYPE> newMap(@Nullable
                                                                                                                          ELEMENTTYPE... aValues)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nullable
                                                                                                           KEYTYPE[] aKeys,
                                                                                                           @Nullable
                                                                                                           VALUETYPE[] aValues)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nullable
                                                                                                           Collection<? extends KEYTYPE> aKeys,
                                                                                                           @Nullable
                                                                                                           Collection<? extends VALUETYPE> aValues)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nullable
                                                                                                           Map<? extends KEYTYPE,? extends VALUETYPE> aMap)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nullable
                                                                                                           Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)

newMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsHashMap<KEYTYPE,VALUETYPE> newMap(@Nullable
                                                                                                           Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nonnegative
                                                                                                                        int nInitialCapacity)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap()

newOrderedMapMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCKEYTYPE,SRCVALUETYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsLinkedHashMap<DSTKEYTYPE,DSTVALUETYPE> newOrderedMapMapped(@Nullable
                                                                                                                                                                  Map<? extends SRCKEYTYPE,? extends SRCVALUETYPE> aMap,
                                                                                                                                                                  @Nonnull
                                                                                                                                                                  Function<? super SRCKEYTYPE,? extends DSTKEYTYPE> aKeyMapper,
                                                                                                                                                                  @Nonnull
                                                                                                                                                                  Function<? super SRCVALUETYPE,? extends DSTVALUETYPE> aValueMapper)

newOrderedMapMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCTYPE,DSTKEYTYPE,DSTVALUETYPE> CommonsLinkedHashMap<DSTKEYTYPE,DSTVALUETYPE> newOrderedMapMapped(@Nullable
                                                                                                                                                  Collection<? extends SRCTYPE> aCollection,
                                                                                                                                                  @Nonnull
                                                                                                                                                  Function<? super SRCTYPE,? extends DSTKEYTYPE> aKeyMapper,
                                                                                                                                                  @Nonnull
                                                                                                                                                  Function<? super SRCTYPE,? extends DSTVALUETYPE> aValueMapper)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nullable
                                                                                                                        Map<KEYTYPE,VALUETYPE> aMap,
                                                                                                                        @Nonnull
                                                                                                                        Predicate<Map.Entry<? super KEYTYPE,? super VALUETYPE>> aFilter)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nullable
                                                                                                                        KEYTYPE aKey,
                                                                                                                        @Nullable
                                                                                                                        VALUETYPE aValue)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE> CommonsLinkedHashMap<ELEMENTTYPE,ELEMENTTYPE> newOrderedMap(@Nullable
                                                                                                                                       ELEMENTTYPE... aValues)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nullable
                                                                                                                        KEYTYPE[] aKeys,
                                                                                                                        @Nullable
                                                                                                                        VALUETYPE[] aValues)

Retrieve a map that is ordered in the way the parameter arrays are passed in. Note that key and value arrays need to have the same length.

Type Parameters:

KEYTYPE - The key type.

VALUETYPE - The value type.

Parameters:

aKeys - The key array to use. May not be null.

aValues - The value array to use. May not be null.

Returns:

A CommonsLinkedHashMap containing the passed key-value entries. Never null.

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nullable
                                                                                                                        Collection<? extends KEYTYPE> aKeys,
                                                                                                                        @Nullable
                                                                                                                        Collection<? extends VALUETYPE> aValues)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nullable
                                                                                                                        Map<? extends KEYTYPE,? extends VALUETYPE> aMap)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nullable
                                                                                                                        Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> CommonsLinkedHashMap<KEYTYPE,VALUETYPE> newOrderedMap(@Nullable
                                                                                                                        Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap()

newSortedMapMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCKEYTYPE,SRCVALUETYPE,DSTKEYTYPE extends Comparable<? super DSTKEYTYPE>,DSTVALUETYPE> CommonsTreeMap<DSTKEYTYPE,DSTVALUETYPE> newSortedMapMapped(@Nullable
                                                                                                                                                                                                  Map<? extends SRCKEYTYPE,? extends SRCVALUETYPE> aMap,
                                                                                                                                                                                                  @Nonnull
                                                                                                                                                                                                  Function<? super SRCKEYTYPE,DSTKEYTYPE> aKeyMapper,
                                                                                                                                                                                                  @Nonnull
                                                                                                                                                                                                  Function<? super SRCVALUETYPE,DSTVALUETYPE> aValueMapper)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap(@Nullable
                                                                                                                                                     Map<KEYTYPE,VALUETYPE> aMap,
                                                                                                                                                     @Nonnull
                                                                                                                                                     Predicate<Map.Entry<? super KEYTYPE,? super VALUETYPE>> aFilter)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap(@Nullable
                                                                                                                                                     KEYTYPE aKey,
                                                                                                                                                     @Nullable
                                                                                                                                                     VALUETYPE aValue)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeMap<ELEMENTTYPE,ELEMENTTYPE> newSortedMap(@Nullable
                                                                                                                                                                        ELEMENTTYPE... aValues)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap(@Nullable
                                                                                                                                                     KEYTYPE[] aKeys,
                                                                                                                                                     @Nullable
                                                                                                                                                     VALUETYPE[] aValues)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap(@Nullable
                                                                                                                                                     Collection<? extends KEYTYPE> aKeys,
                                                                                                                                                     @Nullable
                                                                                                                                                     Collection<? extends VALUETYPE> aValues)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap(@Nullable
                                                                                                                                                     Map<? extends KEYTYPE,? extends VALUETYPE> aMap)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap(@Nullable
                                                                                                                                                     Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)

newSortedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> CommonsTreeMap<KEYTYPE,VALUETYPE> newSortedMap(@Nullable
                                                                                                                                                     Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nonnegative
                                                                                               int nInitialCapacity)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet()

newSetMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCTYPE,DSTTYPE> CommonsHashSet<DSTTYPE> newSetMapped(@Nullable
                                                                                                     Collection<? extends SRCTYPE> aCollection,
                                                                                                     @Nonnull
                                                                                                     Function<? super SRCTYPE,DSTTYPE> aMapper)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                               Collection<? extends ELEMENTTYPE> aCollection,
                                                                                               @Nonnull
                                                                                               Predicate<? super ELEMENTTYPE> aFilter)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                               ELEMENTTYPE aValue)

newSet

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                                              ELEMENTTYPE... aValues)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                               Iterable<? extends ELEMENTTYPE> aCont)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                               Collection<? extends ELEMENTTYPE> aCont)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                               Iterator<? extends ELEMENTTYPE> aIter)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                               IIterableIterator<? extends ELEMENTTYPE> aIter)

newSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsHashSet<ELEMENTTYPE> newSet(@Nullable
                                                                                               Enumeration<? extends ELEMENTTYPE> aEnum)

newEnumSet

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE extends Enum<ELEMENTTYPE>> EnumSet<ELEMENTTYPE> newEnumSet(@Nonnull
                                                                                                                                     Class<ELEMENTTYPE> aEnumClass,
                                                                                                                                     @Nullable
                                                                                                                                     ELEMENTTYPE... aValues)

newEnumSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Enum<ELEMENTTYPE>> EnumSet<ELEMENTTYPE> newEnumSet(@Nonnull
                                                                                                                      Class<ELEMENTTYPE> aEnumClass,
                                                                                                                      @Nullable
                                                                                                                      Collection<ELEMENTTYPE> aValues)

newEnumSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Enum<ELEMENTTYPE>> EnumSet<ELEMENTTYPE> newEnumSet(@Nonnull
                                                                                                                      Class<ELEMENTTYPE> aEnumClass,
                                                                                                                      @Nullable
                                                                                                                      EnumSet<ELEMENTTYPE> aValues)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet()

newSortedSetMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCTYPE,DSTTYPE extends Comparable<? super DSTTYPE>> CommonsTreeSet<DSTTYPE> newSortedSetMapped(@Nullable
                                                                                                                                               Collection<? extends SRCTYPE> aCollection,
                                                                                                                                               @Nonnull
                                                                                                                                               Function<? super SRCTYPE,DSTTYPE> aMapper)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                             Collection<? extends ELEMENTTYPE> aCollection,
                                                                                                                                             @Nonnull
                                                                                                                                             Predicate<? super ELEMENTTYPE> aFilter)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                             ELEMENTTYPE aValue)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                                            ELEMENTTYPE... aValues)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                             Iterable<? extends ELEMENTTYPE> aCont)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                             Collection<? extends ELEMENTTYPE> aCont)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                             Iterator<? extends ELEMENTTYPE> aIter)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                             IIterableIterator<? extends ELEMENTTYPE> aIter)

newSortedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsTreeSet<ELEMENTTYPE> newSortedSet(@Nullable
                                                                                                                                             Enumeration<? extends ELEMENTTYPE> aEnum)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nonnegative
                                                                                                            int nInitialCapacity)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet()

newOrderedSetMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCTYPE,DSTTYPE> CommonsLinkedHashSet<DSTTYPE> newOrderedSetMapped(@Nullable
                                                                                                                  Collection<? extends SRCTYPE> aCollection,
                                                                                                                  @Nonnull
                                                                                                                  Function<? super SRCTYPE,DSTTYPE> aMapper)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nullable
                                                                                                            Collection<? extends ELEMENTTYPE> aCollection,
                                                                                                            @Nonnull
                                                                                                            Predicate<? super ELEMENTTYPE> aFilter)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nullable
                                                                                                            ELEMENTTYPE aValue)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nullable
                                                                                                                           ELEMENTTYPE... aValues)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nullable
                                                                                                            Iterable<? extends ELEMENTTYPE> aCont)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nullable
                                                                                                            Collection<? extends ELEMENTTYPE> aCont)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nonnull
                                                                                                            Iterator<? extends ELEMENTTYPE> aIter)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nullable
                                                                                                            IIterableIterator<? extends ELEMENTTYPE> aIter)

newOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsLinkedHashSet<ELEMENTTYPE> newOrderedSet(@Nullable
                                                                                                            Enumeration<? extends ELEMENTTYPE> aEnum)

newListPrefilled

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newListPrefilled(@Nullable
                                                                                                           ELEMENTTYPE aValue,
                                                                                                           @Nonnegative
                                                                                                           int nElements)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nonnegative
                                                                                                  int nInitialCapacity)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList()

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                  Collection<? extends ELEMENTTYPE> aCollection,
                                                                                                  @Nonnull
                                                                                                  Predicate<? super ELEMENTTYPE> aFilter)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                  ELEMENTTYPE aValue)

newList

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                                 ELEMENTTYPE... aValues)

newListMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCTYPE,DSTTYPE> CommonsArrayList<DSTTYPE> newListMapped(@Nullable
                                                                                                        SRCTYPE[] aValues,
                                                                                                        @Nonnull
                                                                                                        Function<? super SRCTYPE,? extends DSTTYPE> aMapper)

newListMapped

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE,DSTTYPE> CommonsArrayList<DSTTYPE> newListMapped(@Nullable
                                                                                                            Iterable<? extends ELEMENTTYPE> aIter,
                                                                                                            @Nonnull
                                                                                                            Function<? super ELEMENTTYPE,? extends DSTTYPE> aMapper)

newListMapped

@Nonnull
 @ReturnsMutableCopy
public static <SRCTYPE,DSTTYPE> CommonsArrayList<DSTTYPE> newListMapped(@Nullable
                                                                                                        Collection<? extends SRCTYPE> aCollection,
                                                                                                        @Nonnull
                                                                                                        Function<? super SRCTYPE,? extends DSTTYPE> aMapper)

newListMapped

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE,DSTTYPE> CommonsArrayList<DSTTYPE> newListMapped(@Nullable
                                                                                                            Iterable<? extends ELEMENTTYPE> aCollection,
                                                                                                            @Nullable
                                                                                                            Predicate<? super ELEMENTTYPE> aFilter,
                                                                                                            @Nonnull
                                                                                                            Function<? super ELEMENTTYPE,? extends DSTTYPE> aMapper)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                  Enumeration<? extends ELEMENTTYPE> aEnum)

Compared to Collections.list(Enumeration) this method is more flexible in Generics parameter.

Type Parameters:

ELEMENTTYPE - Type of the elements

Parameters:

aEnum - The enumeration to be converted

Returns:

The non-null created CommonsArrayList.

See Also:

Collections.list(Enumeration)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                  Iterator<? extends ELEMENTTYPE> aIter)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                  Iterable<? extends ELEMENTTYPE> aIter)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                  Collection<? extends ELEMENTTYPE> aCont)

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> newList(@Nullable
                                                                                                  IIterableIterator<? extends ELEMENTTYPE> aIter)

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                                                            IIterableIterator<? extends ELEMENTTYPE> aIter)

Convert the given iterator to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of elements to iterate. May not be null.

Parameters:

aIter - Input iterator. May be null.

Returns:

a non-null CommonsArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                                                            IIterableIterator<? extends ELEMENTTYPE> aIter,
                                                                                                                                            @Nonnull
                                                                                                                                            Comparator<? super ELEMENTTYPE> aComparator)

Convert the given iterator to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of elements to iterate. May not be null.

Parameters:

aIter - Input iterator. May be null.

aComparator - The comparator to use. May not be null.

Returns:

a non-null CommonsArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                                                            Iterator<? extends ELEMENTTYPE> aIter)

Convert the given iterator to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of elements to iterate. May not be null.

Parameters:

aIter - Input iterator. May not be null.

Returns:

a non-null CommonsArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                    Iterator<? extends ELEMENTTYPE> aIter,
                                                                                                    @Nonnull
                                                                                                    Comparator<? super ELEMENTTYPE> aComparator)

Convert the given iterator to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of elements to iterate.

Parameters:

aIter - Input iterator. May be null.

aComparator - The comparator to use. May not be null.

Returns:

a non-null CommonsArrayList based on the results of Collections.sort(List, Comparator).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                                                            Iterable<? extends ELEMENTTYPE> aCont)

Convert the given iterable object to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of element to iterate.

Parameters:

aCont - Iterable input object. May be null.

Returns:

A CommonsArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                    Iterable<? extends ELEMENTTYPE> aCont,
                                                                                                    @Nonnull
                                                                                                    Comparator<? super ELEMENTTYPE> aComparator)

Convert the given iterable object to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of element to iterate.

Parameters:

aCont - Iterable input object. May be null.

aComparator - The comparator to use. May not be null.

Returns:

A CommonsArrayList based on the results of Collections.sort(List, Comparator).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                                                            Collection<? extends ELEMENTTYPE> aCont)

Convert the given collection object to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of element to iterate.

Parameters:

aCont - Collection input object. May be null.

Returns:

A CommonsArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                    Collection<? extends ELEMENTTYPE> aCont,
                                                                                                    @Nonnull
                                                                                                    Comparator<? super ELEMENTTYPE> aComparator)

Convert the given collection object to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of element to iterate.

Parameters:

aCont - Collection input object. May be null.

aComparator - The comparator to use. May not be null.

Returns:

A CommonsArrayList based on the results of Collections.sort(List, Comparator).

getSorted

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                                                                           ELEMENTTYPE... aCont)

Convert the given iterable object to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of element to iterate.

Parameters:

aCont - Array input object. May be null.

Returns:

A CommonsArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getSorted(@Nullable
                                                                                                    ELEMENTTYPE[] aCont,
                                                                                                    @Nonnull
                                                                                                    Comparator<? super ELEMENTTYPE> aComparator)

Convert the given iterable object to a sorted list.

Type Parameters:

ELEMENTTYPE - The type of element to iterate.

Parameters:

aCont - Iterable input object. May be null.

aComparator - The comparator to use. May not be null.

Returns:

A CommonsArrayList based on the results of Collections.sort(List, Comparator).

getSortedInline

@Nullable
 @ReturnsMutableObject(value="design")
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>,LISTTYPE extends List<ELEMENTTYPE>> LISTTYPE getSortedInline(@Nullable
                                                                                                                                                                                   LISTTYPE aList)

getSortedInline

@Nullable
 @ReturnsMutableObject(value="design")
public static <ELEMENTTYPE,LISTTYPE extends List<ELEMENTTYPE>> LISTTYPE getSortedInline(@Nullable
                                                                                                                                           LISTTYPE aList,
                                                                                                                                           @Nonnull
                                                                                                                                           Comparator<? super ELEMENTTYPE> aComparator)

getSortedByKey

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> ICommonsMap<KEYTYPE,VALUETYPE> getSortedByKey(@Nullable
                                                                                                                                                    Map<KEYTYPE,VALUETYPE> aMap)

Get a map sorted by aIter's keys. Because no comparator is defined, the key type needs to implement the Comparable interface.

Type Parameters:

KEYTYPE - map key type

VALUETYPE - map value type

Parameters:

aMap - the map to sort

Returns:

the sorted map and never null.

getSortedByKey

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> ICommonsMap<KEYTYPE,VALUETYPE> getSortedByKey(@Nullable
                                                                                                                Map<KEYTYPE,VALUETYPE> aMap,
                                                                                                                @Nonnull
                                                                                                                Comparator<? super KEYTYPE> aKeyComparator)

Get a map sorted by its keys. The comparison order is defined by the passed comparator object.

Type Parameters:

KEYTYPE - map key type

VALUETYPE - map value type

Parameters:

aMap - The map to sort. May not be null.

aKeyComparator - The comparator to be used. May not be null.

Returns:

the sorted map and never null.

getSortedByValue

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE extends Comparable<? super VALUETYPE>> ICommonsMap<KEYTYPE,VALUETYPE> getSortedByValue(@Nullable
                                                                                                                                                        Map<KEYTYPE,VALUETYPE> aMap)

Get a map sorted by its values. Because no comparator is defined, the value type needs to implement the Comparable interface.

Type Parameters:

KEYTYPE - map key type

VALUETYPE - map value type

Parameters:

aMap - The map to sort. May not be null.

Returns:

the sorted map and never null.

getSortedByValue

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> ICommonsMap<KEYTYPE,VALUETYPE> getSortedByValue(@Nullable
                                                                                                                  Map<KEYTYPE,VALUETYPE> aMap,
                                                                                                                  @Nonnull
                                                                                                                  Comparator<? super VALUETYPE> aValueComparator)

Get a map sorted by aIter's values. The comparison order is defined by the passed comparator object.

Type Parameters:

KEYTYPE - map key type

VALUETYPE - map value type

Parameters:

aMap - The map to sort. May not be null.

aValueComparator - The comparator to be used. May not be null.

Returns:

the sorted map and never null.

getReverseList

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getReverseList(@Nullable
                                                                                                          Collection<? extends ELEMENTTYPE> aCollection)

getReverseInlineList

@Nullable
 @ReturnsMutableObject(value="semantics of this method")
public static <ELEMENTTYPE,LISTTYPE extends List<ELEMENTTYPE>> LISTTYPE getReverseInlineList(@Nullable
                                                                                                                                                                  LISTTYPE aList)

getFilteredMap

@Nullable
 @ReturnsMutableCopy
public static <KEY,VALUE> ICommonsMap<KEY,VALUE> getFilteredMap(@Nullable
                                                                                                 ICommonsMap<KEY,VALUE> aValues,
                                                                                                 @Nullable
                                                                                                 Collection<? extends KEY> aKeys)

Get a map consisting only of a set of specified keys. If an element from the key set is not contained in the original map, the key is ignored.

Type Parameters:

KEY - Source map key type.

VALUE - Source map value type.

Parameters:

aValues - Source map to filter. May not be null.

aKeys - The filter set to filter the entries from. May not be null.

Returns:

A non-null map containing only the elements from the specified key set.

getFirstElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getFirstElement(@Nullable
                                                                   List<ELEMENTTYPE> aList)

Get the first element of the passed list.

Type Parameters:

ELEMENTTYPE - List element type

Parameters:

aList - The list. May be null.

Returns:

null if the list is null or empty, the first element otherwise.

getFirstElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getFirstElement(@Nullable
                                                                   Collection<ELEMENTTYPE> aCollection)

Get the first element of the passed collection.

Type Parameters:

ELEMENTTYPE - Collection element type

Parameters:

aCollection - The collection. May be null.

Returns:

null if the collection is null or empty, the first element otherwise.

getFirstElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getFirstElement(@Nullable
                                                                   Iterable<ELEMENTTYPE> aIterable)

Get the first element of the passed iterable.

Type Parameters:

ELEMENTTYPE - Iterable element type

Parameters:

aIterable - The iterable. May be null.

Returns:

null if the iterable is null or empty, the first element otherwise.

removeFirstElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE removeFirstElement(@Nullable
                                                                      List<ELEMENTTYPE> aList)

getLastElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getLastElement(@Nullable
                                                                  List<ELEMENTTYPE> aList)

getLastElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getLastElement(@Nullable
                                                                  Collection<ELEMENTTYPE> aCollection)

getLastElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getLastElement(@Nullable
                                                                  Iterable<ELEMENTTYPE> aIterable)

removeAtIndex

@Nonnull
public static EChange removeAtIndex(@Nullable
                                              List<?> aList,
                                              int nIndex)

Remove the element at the specified index from the passed list. This works if the list is not null and the index is ≥ 0 and < list.size()

Parameters:

aList - The list to remove an element from. May be null.

nIndex - The index to be removed. May be arbitrary.

Returns:

EChange.CHANGED if removal was successful

See Also:

removeAndReturnElementAtIndex(List, int)

removeAndReturnElementAtIndex

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE removeAndReturnElementAtIndex(@Nullable
                                                                                 List<ELEMENTTYPE> aList,
                                                                                 int nIndex)

Remove the element at the specified index from the passed list. This works if the list is not null and the index is ≥ 0 and < list.size()

Type Parameters:

ELEMENTTYPE - List element type

Parameters:

aList - The list to remove an element from. May be null.

nIndex - The index to be removed. May be arbitrary.

Returns:

null if removal failed or the removed element. Note: the removed element may also be null so it may be tricky to determine if removal succeeded or not!

See Also:

removeAtIndex(List, int)

removeLastElement

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE removeLastElement(@Nullable
                                                                     List<ELEMENTTYPE> aList)

isEmpty

public static boolean isEmpty(@Nullable
                              Iterable<?> aCont)

isEmpty

public static boolean isEmpty(@Nullable
                              Collection<?> aCont)

isEmpty

public static boolean isEmpty(@Nullable
                              Map<?,?> aCont)

isNotEmpty

public static boolean isNotEmpty(@Nullable
                                 Iterable<?> aCont)

isNotEmpty

public static boolean isNotEmpty(@Nullable
                                 Collection<?> aCont)

isNotEmpty

public static boolean isNotEmpty(@Nullable
                                 Map<?,?> aCont)

getSize

@Nonnegative
public static int getSize(@Nullable
                                        Collection<?> aCollection)

Retrieve the size of the passed Collection. This method handles null containers.

Parameters:

aCollection - Object to check. May be null.

Returns:

The size of the object or 0 if the passed parameter is null.

getSize

@Nonnegative
public static int getSize(@Nullable
                                        Map<?,?> aMap)

Retrieve the size of the passed Map. This method handles null containers.

Parameters:

aMap - Object to check. May be null.

Returns:

The size of the object or 0 if the passed parameter is null.

getSize

@Nonnegative
public static int getSize(@Nullable
                                        Iterable<?> aIterable)

Retrieve the size of the passed Iterable.

Parameters:

aIterable - Iterator to check. May be null.

Returns:

The number objects or 0 if the passed parameter is null.

getConcatenatedList

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getConcatenatedList(@Nullable
                                                                                                               Collection<? extends ELEMENTTYPE> aCollection1,
                                                                                                               @Nullable
                                                                                                               Collection<? extends ELEMENTTYPE> aCollection2)

getConcatenatedList

@Nullable
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getConcatenatedList(@Nullable
                                                                                                                              Collection<? extends ELEMENTTYPE> aCont1,
                                                                                                                              @Nullable
                                                                                                                              ELEMENTTYPE... aCont2)

getConcatenatedList

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getConcatenatedList(@Nullable
                                                                                                               ELEMENTTYPE[] aCont1,
                                                                                                               @Nullable
                                                                                                               Collection<? extends ELEMENTTYPE> aCont2)

getConcatenatedSet

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE> getConcatenatedSet(@Nullable
                                                                                                         Collection<? extends ELEMENTTYPE> aCont1,
                                                                                                         @Nullable
                                                                                                         Collection<? extends ELEMENTTYPE> aCont2)

getConcatenatedSet

@Nonnull
 @ReturnsMutableCopy
 @SafeVarargs
public static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE> getConcatenatedSet(@Nullable
                                                                                                                       Collection<? extends ELEMENTTYPE> aCont1,
                                                                                                                       @Nullable
                                                                                                                       ELEMENTTYPE... aCont2)

getConcatenatedSet

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> ICommonsSet<ELEMENTTYPE> getConcatenatedSet(@Nullable
                                                                                                        ELEMENTTYPE[] aCont1,
                                                                                                        @Nullable
                                                                                                        Collection<? extends ELEMENTTYPE> aCont2)

getConcatenatedInline

@Nonnull
 @ReturnsMutableObject(value="design")
 @SafeVarargs
public static <ELEMENTTYPE,COLLTYPE extends Collection<? super ELEMENTTYPE>> COLLTYPE getConcatenatedInline(@Nonnull
                                                                                                                                                                             COLLTYPE aCont,
                                                                                                                                                                             @Nullable
                                                                                                                                                                             ELEMENTTYPE... aElementsToAdd)

getConcatenatedInline

@Nonnull
 @ReturnsMutableObject(value="design")
public static <ELEMENTTYPE,COLLTYPE extends Collection<? super ELEMENTTYPE>> COLLTYPE getConcatenatedInline(@Nonnull
                                                                                                                                                              COLLTYPE aCont,
                                                                                                                                                              @Nullable
                                                                                                                                                              Collection<? extends ELEMENTTYPE> aElementsToAdd)

getCombinedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEY,VALUE> ICommonsMap<KEY,VALUE> getCombinedMap(@Nullable
                                                                                                Map<KEY,VALUE> aMap1,
                                                                                                @Nullable
                                                                                                Map<KEY,VALUE> aMap2)

Create a map that contains the combination of the other 2 maps. Both maps need to have the same key and value type.

Type Parameters:

KEY - The map key type.

VALUE - The map value type.

Parameters:

aMap1 - The first map. May be null.

aMap2 - The second map. May be null.

Returns:

Never null and always a new object. If both parameters are not null a new map is created, initially containing the entries from the first parameter, afterwards extended by the parameters of the second map potentially overwriting elements from the first map.

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static CommonsArrayList<?> newObjectListFromArray(@Nullable
                                                                                          Object aValue,
                                                                                          @Nonnull
                                                                                          Class<?> aComponentType)

getSubList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> CommonsArrayList<ELEMENTTYPE> getSubList(@Nullable
                                                                                                     List<ELEMENTTYPE> aCont,
                                                                                                     @Nonnegative
                                                                                                     int nStartIndex,
                                                                                                     @Nonnegative
                                                                                                     int nSectionLength)

Gets a sublist excerpt of the passed list.

Type Parameters:

ELEMENTTYPE - Type of elements in list

Parameters:

aCont - The backing list. May not be null.

nStartIndex - The start index to use. Needs to be ≥ 0.

nSectionLength - the length of the desired subset. If list is shorter than that, aIter will return a shorter section

Returns:

The specified section of the passed list, or a shorter list if nStartIndex + nSectionLength is an invalid index. Never null.

contains

public static <ELEMENTTYPE> boolean contains(@Nullable
                                             Collection<? extends ELEMENTTYPE> aCollection,
                                             @Nullable
                                             ELEMENTTYPE aSearch)

findFirst

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE findFirst(@Nullable
                                                             Iterable<? extends ELEMENTTYPE> aCollection,
                                                             @Nullable
                                                             Predicate<? super ELEMENTTYPE> aFilter)

findFirst

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE findFirst(@Nullable
                                                             Iterable<? extends ELEMENTTYPE> aCollection,
                                                             @Nullable
                                                             Predicate<? super ELEMENTTYPE> aFilter,
                                                             @Nullable
                                                             ELEMENTTYPE aDefault)

findFirstMapped

@Nullable
public static <ELEMENTTYPE,DSTTYPE> DSTTYPE findFirstMapped(@Nullable
                                                                       Iterable<? extends ELEMENTTYPE> aCollection,
                                                                       @Nullable
                                                                       Predicate<? super ELEMENTTYPE> aFilter,
                                                                       @Nonnull
                                                                       Function<? super ELEMENTTYPE,DSTTYPE> aMapper)

findFirstMapped

@Nullable
public static <ELEMENTTYPE,DSTTYPE> DSTTYPE findFirstMapped(@Nullable
                                                                       Iterable<? extends ELEMENTTYPE> aCollection,
                                                                       @Nullable
                                                                       Predicate<? super ELEMENTTYPE> aFilter,
                                                                       @Nonnull
                                                                       Function<? super ELEMENTTYPE,DSTTYPE> aMapper,
                                                                       @Nullable
                                                                       DSTTYPE aDefault)

findAll

public static <ELEMENTTYPE> void findAll(@Nullable
                                         Iterable<? extends ELEMENTTYPE> aSrc,
                                         @Nullable
                                         Predicate<? super ELEMENTTYPE> aFilter,
                                         @Nonnull
                                         Collection<? super ELEMENTTYPE> aDst)

findAll

public static <ELEMENTTYPE> void findAll(@Nullable
                                         Iterable<? extends ELEMENTTYPE> aSrc,
                                         @Nullable
                                         Predicate<? super ELEMENTTYPE> aFilter,
                                         @Nonnull
                                         Consumer<? super ELEMENTTYPE> aConsumer)

findAllMapped

public static <SRCTYPE,DSTTYPE> void findAllMapped(@Nullable
                                                   Iterable<? extends SRCTYPE> aSrc,
                                                   @Nonnull
                                                   Function<? super SRCTYPE,? extends DSTTYPE> aMapper,
                                                   @Nonnull
                                                   Collection<? super DSTTYPE> aDst)

findAllMapped

public static <SRCTYPE,DSTTYPE> void findAllMapped(@Nullable
                                                   Iterable<? extends SRCTYPE> aSrc,
                                                   @Nonnull
                                                   Function<? super SRCTYPE,? extends DSTTYPE> aMapper,
                                                   @Nonnull
                                                   Consumer<? super DSTTYPE> aConsumer)

findAllMapped

public static <SRCTYPE,DSTTYPE> void findAllMapped(@Nullable
                                                   Iterable<? extends SRCTYPE> aSrc,
                                                   @Nullable
                                                   Predicate<? super SRCTYPE> aFilter,
                                                   @Nonnull
                                                   Function<? super SRCTYPE,? extends DSTTYPE> aMapper,
                                                   @Nonnull
                                                   Collection<? super DSTTYPE> aDst)

findAllMapped

public static <SRCTYPE,DSTTYPE> void findAllMapped(@Nullable
                                                   Iterable<? extends SRCTYPE> aSrc,
                                                   @Nullable
                                                   Predicate<? super SRCTYPE> aFilter,
                                                   @Nonnull
                                                   Function<? super SRCTYPE,? extends DSTTYPE> aMapper,
                                                   @Nonnull
                                                   Consumer<? super DSTTYPE> aConsumer)

getCount

@Nonnegative
public static <ELEMENTTYPE> int getCount(@Nullable
                                                       Iterable<? extends ELEMENTTYPE> aCollection,
                                                       @Nullable
                                                       Predicate<? super ELEMENTTYPE> aFilter)

containsAny

public static <ELEMENTTYPE> boolean containsAny(@Nullable
                                                Iterable<? extends ELEMENTTYPE> aCollection,
                                                @Nullable
                                                Predicate<? super ELEMENTTYPE> aFilter)

containsNone

public static <ELEMENTTYPE> boolean containsNone(@Nullable
                                                 Iterable<? extends ELEMENTTYPE> aCollection,
                                                 @Nullable
                                                 Predicate<? super ELEMENTTYPE> aFilter)

containsOnly

public static <ELEMENTTYPE> boolean containsOnly(@Nullable
                                                 Iterable<? extends ELEMENTTYPE> aCollection,
                                                 @Nonnull
                                                 Predicate<? super ELEMENTTYPE> aFilter)

Check if the passed collection contains only elements matching the predicate. An empty collection does not fulfill this requirement!

Type Parameters:

ELEMENTTYPE - Collection data type

Parameters:

aCollection - The collection to check. May be null.

aFilter - Predicate to check against all elements. May not be null.

Returns:

true only if the passed collection is neither null nor empty and if only matching elements are contained.

containsAnyNullElement

public static boolean containsAnyNullElement(@Nullable
                                             Iterable<?> aCont)

Check if the passed collection contains at least one null element.

Parameters:

aCont - The collection to check. May be null.

Returns:

true only if the passed collection is neither null nor empty and if at least one null element is contained.

containsOnlyNullElements

public static boolean containsOnlyNullElements(@Nullable
                                               Iterable<?> aCont)

Check if the passed collection contains only null element.

Parameters:

aCont - The collection to check. May be null.

Returns:

true only if the passed collection is neither null nor empty and if at least one null element is contained.

getAtIndex

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getAtIndex(@Nullable
                                                              List<? extends ELEMENTTYPE> aList,
                                                              int nIndex)

Safe list element accessor method.

Type Parameters:

ELEMENTTYPE - The type of elements on the list.

Parameters:

aList - The list to extract from. May be null.

nIndex - The index to access. Should be ≥ 0.

Returns:

null if the element cannot be accessed.

getAtIndex

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getAtIndex(@Nullable
                                                              List<? extends ELEMENTTYPE> aList,
                                                              int nIndex,
                                                              @Nullable
                                                              ELEMENTTYPE aDefault)

Safe list element accessor method.

Type Parameters:

ELEMENTTYPE - The type of elements on the list.

Parameters:

aList - The list to extract from. May be null.

nIndex - The index to access. Should be ≥ 0.

aDefault - The value to be returned, if the index is out of bounds.

Returns:

The default parameter if the element cannot be accessed.

getAtIndex

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getAtIndex(@Nullable
                                                              Iterable<? extends ELEMENTTYPE> aCollection,
                                                              @Nonnegative
                                                              int nIndex)

getAtIndex

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getAtIndex(@Nullable
                                                              Iterable<? extends ELEMENTTYPE> aCollection,
                                                              @Nonnegative
                                                              int nIndex,
                                                              @Nullable
                                                              ELEMENTTYPE aDefault)

getAtIndex

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getAtIndex(@Nullable
                                                              Iterable<? extends ELEMENTTYPE> aCollection,
                                                              @Nullable
                                                              Predicate<? super ELEMENTTYPE> aFilter,
                                                              @Nonnegative
                                                              int nIndex)

getAtIndex

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getAtIndex(@Nullable
                                                              Iterable<? extends ELEMENTTYPE> aCollection,
                                                              @Nullable
                                                              Predicate<? super ELEMENTTYPE> aFilter,
                                                              @Nonnegative
                                                              int nIndex,
                                                              @Nullable
                                                              ELEMENTTYPE aDefault)

getAtIndexMapped

@Nullable
public static <SRCTYPE,DSTTYPE> DSTTYPE getAtIndexMapped(@Nullable
                                                                    Iterable<? extends SRCTYPE> aCollection,
                                                                    @Nullable
                                                                    Predicate<? super SRCTYPE> aFilter,
                                                                    @Nonnegative
                                                                    int nIndex,
                                                                    @Nonnull
                                                                    Function<? super SRCTYPE,? extends DSTTYPE> aMapper)

getAtIndexMapped

@Nullable
public static <SRCTYPE,DSTTYPE> DSTTYPE getAtIndexMapped(@Nullable
                                                                    Iterable<? extends SRCTYPE> aCollection,
                                                                    @Nullable
                                                                    Predicate<? super SRCTYPE> aFilter,
                                                                    @Nonnegative
                                                                    int nIndex,
                                                                    @Nonnull
                                                                    Function<? super SRCTYPE,? extends DSTTYPE> aMapper,
                                                                    @Nullable
                                                                    DSTTYPE aDefault)