CollectionHelper (ph-commons 6.2.3 API)

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

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`containsAnyNullElement(Iterable<?> aCont)` Check if the passed collection contains at least one `null` element.
`static boolean`	`containsOnlyNullElements(Iterable<?> aCont)` Check if the passed collection contains only `null` element.
`static List<?>`	`getAsList(Object aObj)` Get the passed object as a `List` object.
`static ECollectionBaseType`	`getCollectionBaseTypeOfClass(Class<?> aClass)`
`static ECollectionBaseType`	`getCollectionBaseTypeOfObject(Object aObj)`
`static <ELEMENTTYPE> Iterator<ELEMENTTYPE>`	`getCombinedIterator(Iterator<? extends ELEMENTTYPE> aIter1, Iterator<? extends ELEMENTTYPE> aIter2)` Get a merged iterator of both iterators.
`static <KEY,VALUE> Map<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> List<ELEMENTTYPE>`	`getConcatenatedList(Collection<? extends ELEMENTTYPE> aCollection1, Collection<? extends ELEMENTTYPE> aCollection2)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`getConcatenatedList(Collection<? extends ELEMENTTYPE> aCont1, ELEMENTTYPE... aCont2)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`getConcatenatedList(ELEMENTTYPE[] aCont1, Collection<? extends ELEMENTTYPE> aCont2)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`getConcatenatedSet(Collection<? extends ELEMENTTYPE> aCont1, Collection<? extends ELEMENTTYPE> aCont2)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`getConcatenatedSet(Collection<? extends ELEMENTTYPE> aCont1, ELEMENTTYPE... aCont2)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`getConcatenatedSet(ELEMENTTYPE[] aCont1, Collection<? extends ELEMENTTYPE> aCont2)`
`static <ELEMENTTYPE> Set<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 <ELEMENTTYPE> Enumeration<ELEMENTTYPE>`	`getEmptyEnumeration()` Create an empty enumeration.
`static <ELEMENTTYPE> Iterator<ELEMENTTYPE>`	`getEmptyIterator()` Create an empty iterator.
`static <ELEMENTTYPE> Enumeration<ELEMENTTYPE>`	`getEnumeration(ELEMENTTYPE... aArray)` Get an `Enumeration` object based on the passed array.
`static <ELEMENTTYPE> Enumeration<ELEMENTTYPE>`	`getEnumeration(Iterable<ELEMENTTYPE> aCont)` Get an `Enumeration` object based on a `Collection` object.
`static <ELEMENTTYPE> Enumeration<ELEMENTTYPE>`	`getEnumeration(Iterator<ELEMENTTYPE> aIter)` Get an Enumeration object based on an Iterator object.
`static <KEYTYPE,VALUETYPE> Enumeration<Map.Entry<KEYTYPE,VALUETYPE>>`	`getEnumeration(Map<KEYTYPE,VALUETYPE> aMap)` Get an Enumeration object based on a Map object.
`static <KEY,VALUE> Map<KEY,VALUE>`	`getFilteredMap(Map<KEY,VALUE> aValues, Collection<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 <KEYTYPE,VALUETYPE> Map.Entry<KEYTYPE,VALUETYPE>`	`getFirstElement(Map<KEYTYPE,VALUETYPE> aMap)` Get the first element of the passed map.
`static <ELEMENTTYPE> ELEMENTTYPE`	`getFirstElement(SortedSet<ELEMENTTYPE> aSortedSet)` Get the first element of the passed sorted set.
`static <KEYTYPE,VALUETYPE> KEYTYPE`	`getFirstKey(Map<KEYTYPE,VALUETYPE> aMap)` Get the first key of the passed map.
`static <KEYTYPE,VALUETYPE> KEYTYPE`	`getFirstKey(SortedMap<KEYTYPE,VALUETYPE> aSortedMap)` Get the first key of the passed sorted map.
`static <KEYTYPE,VALUETYPE> VALUETYPE`	`getFirstValue(Map<KEYTYPE,VALUETYPE> aMap)` Get the first value of the passed map.
`static <KEYTYPE,VALUETYPE> VALUETYPE`	`getFirstValue(SortedMap<KEYTYPE,VALUETYPE> aSortedMap)` Get the first value of the passed map.
`static <ELEMENTTYPE> Set<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> Iterator<ELEMENTTYPE>`	`getIterator(ELEMENTTYPE... aArray)`
`static <ELEMENTTYPE> IIterableIterator<ELEMENTTYPE>`	`getIterator(Enumeration<? extends ELEMENTTYPE> aEnum)`
`static <ELEMENTTYPE> Iterator<ELEMENTTYPE>`	`getIterator(Iterable<ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Iterator<ELEMENTTYPE>`	`getIterator(Iterator<ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> ELEMENTTYPE`	`getLastElement(Collection<ELEMENTTYPE> aCollection)`
`static <ELEMENTTYPE> ELEMENTTYPE`	`getLastElement(Iterable<ELEMENTTYPE> aIterable)`
`static <ELEMENTTYPE> ELEMENTTYPE`	`getLastElement(List<ELEMENTTYPE> aList)`
`static <ELEMENTTYPE> ELEMENTTYPE`	`getLastElement(SortedSet<ELEMENTTYPE> aSortedSet)`
`static <KEYTYPE,VALUETYPE> KEYTYPE`	`getLastKey(SortedMap<KEYTYPE,VALUETYPE> aSortedMap)` Get the last key of the passed sorted map.
`static <KEYTYPE,VALUETYPE> VALUETYPE`	`getLastValue(SortedMap<KEYTYPE,VALUETYPE> aSortedMap)` Get the last value of the passed map.
`static <ELEMENTTYPE> List<? extends ELEMENTTYPE>`	`getNotNull(List<? extends ELEMENTTYPE> aList)`
`static <KEYTYPE,VALUETYPE> Map<? extends KEYTYPE,? extends VALUETYPE>`	`getNotNull(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)`
`static <ELEMENTTYPE> Set<? extends ELEMENTTYPE>`	`getNotNull(Set<? extends ELEMENTTYPE> aSet)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<? extends KEYTYPE,? extends VALUETYPE>`	`getNotNull(SortedMap<? extends KEYTYPE,? extends VALUETYPE> aSortedMap)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<? extends ELEMENTTYPE>`	`getNotNull(SortedSet<? extends ELEMENTTYPE> aSortedSet)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`getReverseInlineList(List<ELEMENTTYPE> aList)`
`static <ELEMENTTYPE> Iterator<ELEMENTTYPE>`	`getReverseIterator(List<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`getReverseList(Collection<? extends ELEMENTTYPE> aCollection)`
`static <KEYTYPE,VALUETYPE> IMultiMapSetBased<VALUETYPE,KEYTYPE>`	`getReverseLookup(IMultiMapSetBased<KEYTYPE,VALUETYPE> aMap)` Get a map where the lookup (1K..nV) has been reversed to (1V..nK)
`static <KEYTYPE,VALUETYPE> IMultiMapSetBased<VALUETYPE,KEYTYPE>`	`getReverseLookupSet(IMultiMap<KEYTYPE,VALUETYPE,? extends Collection<VALUETYPE>> aMap)` Get a map where the lookup (1K..nV) has been reversed to (1V..nK)
`static <ELEMENTTYPE> ELEMENTTYPE`	`getSafe(List<ELEMENTTYPE> aList, int nIndex)` Safe list element accessor method.
`static <ELEMENTTYPE> ELEMENTTYPE`	`getSafe(List<ELEMENTTYPE> aList, int nIndex, ELEMENTTYPE aDefault)` Safe list element accessor method.
`static int`	`getSize(Collection<?> aCollection)` Retrieve the size of the passed `Collection`.
`static int`	`getSize(Enumeration<?> aEnumeration)` Retrieve the size of the passed `Enumeration`.
`static int`	`getSize(IIterableIterator<?> aIterator)` Retrieve the size of the passed `Iterable`.
`static int`	`getSize(Iterable<?> aIterable)` Retrieve the size of the passed `Iterable`.
`static int`	`getSize(Iterator<?> aIterator)` Retrieve the size of the passed `Iterator`.
`static int`	`getSize(Map<?,?> aMap)` Retrieve the size of the passed `Map`.
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<ELEMENTTYPE>`	`getSorted(Collection<? extends ELEMENTTYPE> aCont)` Convert the given collection object to a sorted list.
`static <ELEMENTTYPE> List<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>> List<ELEMENTTYPE>`	`getSorted(ELEMENTTYPE... aCont)` Convert the given iterable object to a sorted list.
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`getSorted(ELEMENTTYPE[] aCont, Comparator<? super ELEMENTTYPE> aComparator)` Convert the given iterable object to a sorted list.
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<ELEMENTTYPE>`	`getSorted(IIterableIterator<? extends ELEMENTTYPE> aIter)` Convert the given iterator to a sorted list.
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<ELEMENTTYPE>`	`getSorted(IIterableIterator<? extends ELEMENTTYPE> aIter, Comparator<? super ELEMENTTYPE> aComparator)` Convert the given iterator to a sorted list.
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<ELEMENTTYPE>`	`getSorted(Iterable<? extends ELEMENTTYPE> aCont)` Convert the given iterable object to a sorted list.
`static <ELEMENTTYPE> List<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>> List<ELEMENTTYPE>`	`getSorted(Iterator<? extends ELEMENTTYPE> aIter)` Convert the given iterator to a sorted list.
`static <ELEMENTTYPE> List<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> Map<KEYTYPE,VALUETYPE>`	`getSortedByKey(Map<KEYTYPE,VALUETYPE> aMap)` Get a map sorted by aIter's keys.
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`getSortedByKey(Map<KEYTYPE,VALUETYPE> aMap, Comparator<? super KEYTYPE> aKeyComparator)` Get a map sorted by its keys.
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`getSortedByKey(Map<KEYTYPE,VALUETYPE> aMap, ESortOrder eSortOrder)` Get a map sorted by its keys.
`static <KEYTYPE,VALUETYPE extends Comparable<? super VALUETYPE>> Map<KEYTYPE,VALUETYPE>`	`getSortedByValue(Map<KEYTYPE,VALUETYPE> aMap)` Get a map sorted by its values.
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`getSortedByValue(Map<KEYTYPE,VALUETYPE> aMap, Comparator<? super VALUETYPE> aValueComparator)` Get a map sorted by aIter's values.
`static <KEYTYPE,VALUETYPE extends Comparable<? super VALUETYPE>> Map<KEYTYPE,VALUETYPE>`	`getSortedByValue(Map<KEYTYPE,VALUETYPE> aMap, ESortOrder eSortOrder)` Get a map sorted by its values.
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<ELEMENTTYPE>`	`getSortedInline(List<ELEMENTTYPE> aList)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`getSortedInline(List<ELEMENTTYPE> aList, Comparator<? super ELEMENTTYPE> aComparator)`
`static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE>`	`getStackCopyWithoutTop(NonBlockingStack<ELEMENTTYPE> aStack)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`getSubList(List<ELEMENTTYPE> aCont, int nStartIndex, int nSectionLength)` Gets a sublist excerpt of the passed list.
`static <KEYTYPE,VALUETYPE> Map<VALUETYPE,KEYTYPE>`	`getSwappedKeyValues(Map<KEYTYPE,VALUETYPE> aMap)` Get a map where keys and values are exchanged.
`static boolean`	`isCollectionClass(Class<?> aClass)`
`static boolean`	`isCollectionObject(Object aObj)`
`static boolean`	`isEmpty(Collection<?> aCont)`
`static boolean`	`isEmpty(Enumeration<?> aEnum)`
`static boolean`	`isEmpty(IIterableIterator<?> aIter)`
`static boolean`	`isEmpty(Iterable<?> aCont)`
`static boolean`	`isEmpty(Iterator<?> aIter)`
`static boolean`	`isEmpty(Map<?,?> aCont)`
`static boolean`	`isNotEmpty(Collection<?> aCont)`
`static boolean`	`isNotEmpty(Enumeration<?> aEnum)`
`static boolean`	`isNotEmpty(IIterableIterator<?> aIter)`
`static boolean`	`isNotEmpty(Iterable<?> aCont)`
`static boolean`	`isNotEmpty(Iterator<?> aIter)`
`static boolean`	`isNotEmpty(Map<?,?> aCont)`
`static <ELEMENTTYPE> Collection<ELEMENTTYPE>`	`makeUnmodifiable(Collection<? extends ELEMENTTYPE> aCollection)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`makeUnmodifiable(List<? extends ELEMENTTYPE> aList)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`makeUnmodifiable(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`makeUnmodifiable(Set<? extends ELEMENTTYPE> aSet)`
`static <KEYTYPE,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`makeUnmodifiable(SortedMap<KEYTYPE,? extends VALUETYPE> aSortedMap)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`makeUnmodifiable(SortedSet<ELEMENTTYPE> aSortedSet)`
`static <ELEMENTTYPE> Collection<ELEMENTTYPE>`	`makeUnmodifiableNotNull(Collection<? extends ELEMENTTYPE> aCollection)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`makeUnmodifiableNotNull(List<? extends ELEMENTTYPE> aList)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`makeUnmodifiableNotNull(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`makeUnmodifiableNotNull(Set<? extends ELEMENTTYPE> aSet)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`makeUnmodifiableNotNull(SortedMap<KEYTYPE,? extends VALUETYPE> aSortedMap)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`makeUnmodifiableNotNull(SortedSet<ELEMENTTYPE> aSortedSet)`
`static List<Boolean>`	`newBooleanList(boolean... aValues)`
`static Set<Boolean>`	`newBooleanOrderedSet(boolean... aValues)`
`static Set<Boolean>`	`newBooleanSet(boolean... aValues)`
`static TreeSet<Boolean>`	`newBooleanSortedSet(boolean... aValues)`
`static Vector<Boolean>`	`newBooleanVector(boolean... aValues)`
`static List<Byte>`	`newByteList(byte... aValues)`
`static Set<Byte>`	`newByteOrderedSet(byte... aValues)`
`static Set<Byte>`	`newByteSet(byte... aValues)`
`static TreeSet<Byte>`	`newByteSortedSet(byte... aValues)`
`static Vector<Byte>`	`newByteVector(byte... aValues)`
`static List<Character>`	`newCharList(char... aValues)`
`static Set<Character>`	`newCharOrderedSet(char... aValues)`
`static Set<Character>`	`newCharSet(char... aValues)`
`static TreeSet<Character>`	`newCharSortedSet(char... aValues)`
`static Vector<Character>`	`newCharVector(char... aValues)`
`static List<Double>`	`newDoubleList(double... aValues)`
`static Set<Double>`	`newDoubleOrderedSet(double... aValues)`
`static Set<Double>`	`newDoubleSet(double... aValues)`
`static TreeSet<Double>`	`newDoubleSortedSet(double... aValues)`
`static Vector<Double>`	`newDoubleVector(double... aValues)`
`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 List<Float>`	`newFloatList(float... aValues)`
`static Set<Float>`	`newFloatOrderedSet(float... aValues)`
`static Set<Float>`	`newFloatSet(float... aValues)`
`static TreeSet<Float>`	`newFloatSortedSet(float... aValues)`
`static Vector<Float>`	`newFloatVector(float... aValues)`
`static List<Integer>`	`newIntList(int... aValues)`
`static Set<Integer>`	`newIntOrderedSet(int... aValues)`
`static Set<Integer>`	`newIntSet(int... aValues)`
`static TreeSet<Integer>`	`newIntSortedSet(int... aValues)`
`static Vector<Integer>`	`newIntVector(int... aValues)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList()`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList(Enumeration<? extends ELEMENTTYPE> aEnum)` Compared to `Collections.list(Enumeration)` this method is more flexible in Generics parameter.
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList(Iterable<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newList(Iterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newListPrefilled(ELEMENTTYPE aValue, int nElements)`
`static List<Long>`	`newLongList(long... aValues)`
`static Set<Long>`	`newLongOrderedSet(long... aValues)`
`static Set<Long>`	`newLongSet(long... aValues)`
`static TreeSet<Long>`	`newLongSortedSet(long... aValues)`
`static Vector<Long>`	`newLongVector(long... aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newMap()`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)`
`static <ELEMENTTYPE> Map<ELEMENTTYPE,ELEMENTTYPE>`	`newMap(ELEMENTTYPE... aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newMap(KEYTYPE[] aKeys, VALUETYPE[] aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newMap(KEYTYPE aKey, VALUETYPE aValue)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newMap(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)`
`static List<Boolean>`	`newObjectListFromArray(boolean[] aArray)`
`static List<Byte>`	`newObjectListFromArray(byte[] aArray)`
`static List<Character>`	`newObjectListFromArray(char[] aArray)`
`static List<Double>`	`newObjectListFromArray(double[] aArray)`
`static List<Float>`	`newObjectListFromArray(float[] aArray)`
`static List<Integer>`	`newObjectListFromArray(int[] aArray)`
`static List<Long>`	`newObjectListFromArray(long[] aArray)`
`static List<?>`	`newObjectListFromArray(Object aValue, Class<?> aComponentType)`
`static List<Short>`	`newObjectListFromArray(short[] aArray)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newOrderedMap()`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newOrderedMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newOrderedMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)`
`static <ELEMENTTYPE> Map<ELEMENTTYPE,ELEMENTTYPE>`	`newOrderedMap(ELEMENTTYPE... aValues)`
`static <KEYTYPE,VALUETYPE> Map<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> Map<KEYTYPE,VALUETYPE>`	`newOrderedMap(KEYTYPE aKey, VALUETYPE aValue)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newOrderedMap(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newOrderedMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet()`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet(Enumeration<? extends ELEMENTTYPE> aEnum)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet(Iterable<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newOrderedSet(Iterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue()`
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue(Enumeration<? extends ELEMENTTYPE> aEnum)` Compared to `Collections.list(Enumeration)` this method is more flexible in Generics parameter.
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue(Iterable<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Queue<ELEMENTTYPE>`	`newQueue(Iterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet()`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet(Enumeration<? extends ELEMENTTYPE> aEnum)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet(Iterable<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newSet(Iterator<? extends ELEMENTTYPE> aIter)`
`static List<Short>`	`newShortList(short... aValues)`
`static Set<Short>`	`newShortOrderedSet(short... aValues)`
`static Set<Short>`	`newShortSet(short... aValues)`
`static TreeSet<Short>`	`newShortSortedSet(short... aValues)`
`static Vector<Short>`	`newShortVector(short... aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> TreeMap<KEYTYPE,VALUETYPE>`	`newSortedMap()`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> TreeMap<KEYTYPE,VALUETYPE>`	`newSortedMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> TreeMap<KEYTYPE,VALUETYPE>`	`newSortedMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeMap<ELEMENTTYPE,ELEMENTTYPE>`	`newSortedMap(ELEMENTTYPE... aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> TreeMap<KEYTYPE,VALUETYPE>`	`newSortedMap(KEYTYPE[] aKeys, VALUETYPE[] aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> TreeMap<KEYTYPE,VALUETYPE>`	`newSortedMap(KEYTYPE aKey, VALUETYPE aValue)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> TreeMap<KEYTYPE,VALUETYPE>`	`newSortedMap(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> TreeMap<KEYTYPE,VALUETYPE>`	`newSortedMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet()`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet(Enumeration<? extends ELEMENTTYPE> aEnum)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet(Iterable<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> TreeSet<ELEMENTTYPE>`	`newSortedSet(Iterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE>`	`newStack()`
`static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE>`	`newStack(Collection<? extends ELEMENTTYPE> aValues)` Create a new stack from the given collection.
`static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE>`	`newStack(ELEMENTTYPE... aValues)` Create a new stack from the given array.
`static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE>`	`newStack(ELEMENTTYPE aValue)` Create a new stack with a single element.
`static List<Boolean>`	`newUnmodifiableBooleanList(boolean... aValues)`
`static Set<Boolean>`	`newUnmodifiableBooleanOrderedSet(boolean... aValues)`
`static Set<Boolean>`	`newUnmodifiableBooleanSet(boolean... aValues)`
`static SortedSet<Boolean>`	`newUnmodifiableBooleanSortedSet(boolean... aValues)`
`static List<Byte>`	`newUnmodifiableByteList(byte... aValues)`
`static Set<Byte>`	`newUnmodifiableByteOrderedSet(byte... aValues)`
`static Set<Byte>`	`newUnmodifiableByteSet(byte... aValues)`
`static SortedSet<Byte>`	`newUnmodifiableByteSortedSet(byte... aValues)`
`static List<Character>`	`newUnmodifiableCharList(char... aValues)`
`static Set<Character>`	`newUnmodifiableCharOrderedSet(char... aValues)`
`static Set<Character>`	`newUnmodifiableCharSet(char... aValues)`
`static SortedSet<Character>`	`newUnmodifiableCharSortedSet(char... aValues)`
`static List<Double>`	`newUnmodifiableDoubleList(double... aValues)`
`static Set<Double>`	`newUnmodifiableDoubleOrderedSet(double... aValues)`
`static Set<Double>`	`newUnmodifiableDoubleSet(double... aValues)`
`static SortedSet<Double>`	`newUnmodifiableDoubleSortedSet(double... aValues)`
`static List<Float>`	`newUnmodifiableFloatList(float... aValues)`
`static Set<Float>`	`newUnmodifiableFloatOrderedSet(float... aValues)`
`static Set<Float>`	`newUnmodifiableFloatSet(float... aValues)`
`static SortedSet<Float>`	`newUnmodifiableFloatSortedSet(float... aValues)`
`static List<Integer>`	`newUnmodifiableIntList(int... aValues)`
`static Set<Integer>`	`newUnmodifiableIntOrderedSet(int... aValues)`
`static Set<Integer>`	`newUnmodifiableIntSet(int... aValues)`
`static SortedSet<Integer>`	`newUnmodifiableIntSortedSet(int... aValues)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList()`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList(Enumeration<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList(Iterable<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> List<ELEMENTTYPE>`	`newUnmodifiableList(Iterator<? extends ELEMENTTYPE> aIter)`
`static List<Long>`	`newUnmodifiableLongList(long... aValues)`
`static Set<Long>`	`newUnmodifiableLongOrderedSet(long... aValues)`
`static Set<Long>`	`newUnmodifiableLongSet(long... aValues)`
`static SortedSet<Long>`	`newUnmodifiableLongSortedSet(long... aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableMap()`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)`
`static <ELEMENTTYPE> Map<ELEMENTTYPE,ELEMENTTYPE>`	`newUnmodifiableMap(ELEMENTTYPE... aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableMap(KEYTYPE[] aKeys, VALUETYPE[] aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableMap(KEYTYPE aKey, VALUETYPE aValue)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableMap(Map<? extends KEYTYPE,? extends VALUETYPE> aMap)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableOrderedMap()`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableOrderedMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableOrderedMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)`
`static <ELEMENTTYPE> Map<ELEMENTTYPE,ELEMENTTYPE>`	`newUnmodifiableOrderedMap(ELEMENTTYPE... aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableOrderedMap(KEYTYPE[] aKeys, VALUETYPE[] aValues)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableOrderedMap(KEYTYPE aKey, VALUETYPE aValue)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableOrderedMap(Map<? extends KEYTYPE,? extends VALUETYPE> aOrderedMap)`
`static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE>`	`newUnmodifiableOrderedMap(Map<? extends KEYTYPE,? extends VALUETYPE>[] aOrderedMaps)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet()`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet(Enumeration<? extends ELEMENTTYPE> aEnum)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet(Iterable<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableOrderedSet(Iterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet()`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet(Enumeration<? extends ELEMENTTYPE> aEnum)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet(Iterable<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Set<ELEMENTTYPE>`	`newUnmodifiableSet(Iterator<? extends ELEMENTTYPE> aIter)`
`static List<Short>`	`newUnmodifiableShortList(short... aValues)`
`static Set<Short>`	`newUnmodifiableShortOrderedSet(short... aValues)`
`static Set<Short>`	`newUnmodifiableShortSet(short... aValues)`
`static SortedSet<Short>`	`newUnmodifiableShortSortedSet(short... aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`newUnmodifiableSortedMap()`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`newUnmodifiableSortedMap(Collection<? extends KEYTYPE> aKeys, Collection<? extends VALUETYPE> aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`newUnmodifiableSortedMap(Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedMap<ELEMENTTYPE,ELEMENTTYPE>`	`newUnmodifiableSortedMap(ELEMENTTYPE... aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`newUnmodifiableSortedMap(KEYTYPE[] aKeys, VALUETYPE[] aValues)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`newUnmodifiableSortedMap(KEYTYPE aKey, VALUETYPE aValue)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`newUnmodifiableSortedMap(Map<KEYTYPE,? extends VALUETYPE>[] aMaps)`
`static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE>`	`newUnmodifiableSortedMap(SortedMap<KEYTYPE,? extends VALUETYPE> aMap)`
`static <ELEMENTTYPE> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet()`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet(Enumeration<? extends ELEMENTTYPE> aEnum)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet(Iterable<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE>`	`newUnmodifiableSortedSet(Iterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector()`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector(Collection<? extends ELEMENTTYPE> aCont)`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector(ELEMENTTYPE... aValues)`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector(ELEMENTTYPE aValue)`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector(Enumeration<? extends ELEMENTTYPE> aEnum)` Compared to `Collections.list(Enumeration)` this method is more flexible in Generics parameter.
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector(IIterableIterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector(Iterable<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVector(Iterator<? extends ELEMENTTYPE> aIter)`
`static <ELEMENTTYPE> Vector<ELEMENTTYPE>`	`newVectorPrefilled(ELEMENTTYPE aValue, int nElements)`
`static <ELEMENTTYPE> ELEMENTTYPE`	`removeAndReturnElementAtIndex(List<ELEMENTTYPE> aList, int nIndex)` Remove the element at the specified index from the passed list.
`static EChange`	`removeElementAtIndex(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 List<?> getAsList(@Nonnull
                                          Object aObj)
```
Get the passed object as a List 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<? extends ELEMENTTYPE> getNotNull(@Nullable
                                                                             List<? extends ELEMENTTYPE> aList)

getNotNull

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

getNotNull

@Nonnull
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<? extends ELEMENTTYPE> getNotNull(@Nullable
                                                                                                                          SortedSet<? extends ELEMENTTYPE> aSortedSet)

getNotNull

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

getNotNull

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

makeUnmodifiable

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

makeUnmodifiable

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

makeUnmodifiable

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

makeUnmodifiable

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

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> makeUnmodifiable(@Nullable
                                                                                                                                                 SortedSet<ELEMENTTYPE> aSortedSet)

makeUnmodifiable

@Nullable
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> makeUnmodifiable(@Nullable
                                                                                                                     SortedMap<KEYTYPE,? extends VALUETYPE> aSortedMap)

makeUnmodifiableNotNull

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

makeUnmodifiableNotNull

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

makeUnmodifiableNotNull

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

makeUnmodifiableNotNull

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

makeUnmodifiableNotNull

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

makeUnmodifiableNotNull

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

getDifference

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Set<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> Set<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> Map<KEYTYPE,VALUETYPE> newMap()

newMap

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

newMap

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

newMap

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

newMap

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

newMap

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

newMap

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

newMap

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

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableMap()

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableMap(@Nullable
                                                                                                                KEYTYPE aKey,
                                                                                                                @Nullable
                                                                                                                VALUETYPE aValue)

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Map<ELEMENTTYPE,ELEMENTTYPE> newUnmodifiableMap(@Nullable
                                                                                                                ELEMENTTYPE... aValues)

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableMap(@Nullable
                                                                                                                KEYTYPE[] aKeys,
                                                                                                                @Nullable
                                                                                                                VALUETYPE[] aValues)

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableMap(@Nullable
                                                                                                                Collection<? extends KEYTYPE> aKeys,
                                                                                                                @Nullable
                                                                                                                Collection<? extends VALUETYPE> aValues)

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableMap(@Nullable
                                                                                                                Map<? extends KEYTYPE,? extends VALUETYPE> aMap)

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableMap(@Nullable
                                                                                                                Map<? extends KEYTYPE,? extends VALUETYPE>[] aMaps)

newUnmodifiableMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableMap(@Nullable
                                                                                                                Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)

newOrderedMap

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

newOrderedMap

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

newOrderedMap

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

newOrderedMap

@Nonnull
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> Map<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 LinkedHashMap containing the passed key-value entries. Never null.

newOrderedMap

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

newOrderedMap

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

newOrderedMap

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

newOrderedMap

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

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableOrderedMap()

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableOrderedMap(@Nullable
                                                                                                                       KEYTYPE aKey,
                                                                                                                       @Nullable
                                                                                                                       VALUETYPE aValue)

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Map<ELEMENTTYPE,ELEMENTTYPE> newUnmodifiableOrderedMap(@Nullable
                                                                                                                       ELEMENTTYPE... aValues)

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableOrderedMap(@Nullable
                                                                                                                       KEYTYPE[] aKeys,
                                                                                                                       @Nullable
                                                                                                                       VALUETYPE[] aValues)

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableOrderedMap(@Nullable
                                                                                                                       Collection<? extends KEYTYPE> aKeys,
                                                                                                                       @Nullable
                                                                                                                       Collection<? extends VALUETYPE> aValues)

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableOrderedMap(@Nullable
                                                                                                                       Map<? extends KEYTYPE,? extends VALUETYPE> aOrderedMap)

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableOrderedMap(@Nullable
                                                                                                                       Map<? extends KEYTYPE,? extends VALUETYPE>[] aOrderedMaps)

newUnmodifiableOrderedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE,VALUETYPE> Map<KEYTYPE,VALUETYPE> newUnmodifiableOrderedMap(@Nullable
                                                                                                                       Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)

newSortedMap

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

newSortedMap

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

newSortedMap

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

newSortedMap

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

newSortedMap

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

newSortedMap

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

newSortedMap

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

newSortedMap

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

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> newUnmodifiableSortedMap()

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> newUnmodifiableSortedMap(@Nullable
                                                                                                                                                                KEYTYPE aKey,
                                                                                                                                                                @Nullable
                                                                                                                                                                VALUETYPE aValue)

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedMap<ELEMENTTYPE,ELEMENTTYPE> newUnmodifiableSortedMap(@Nullable
                                                                                                                                                                    ELEMENTTYPE... aValues)

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> newUnmodifiableSortedMap(@Nullable
                                                                                                                                                                KEYTYPE[] aKeys,
                                                                                                                                                                @Nullable
                                                                                                                                                                VALUETYPE[] aValues)

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> newUnmodifiableSortedMap(@Nullable
                                                                                                                                                                Collection<? extends KEYTYPE> aKeys,
                                                                                                                                                                @Nullable
                                                                                                                                                                Collection<? extends VALUETYPE> aValues)

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> newUnmodifiableSortedMap(@Nullable
                                                                                                                                                                SortedMap<KEYTYPE,? extends VALUETYPE> aMap)

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> newUnmodifiableSortedMap(@Nullable
                                                                                                                                                                Map<KEYTYPE,? extends VALUETYPE>[] aMaps)

newUnmodifiableSortedMap

@Nonnull
 @ReturnsImmutableObject
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<KEYTYPE,VALUETYPE> newUnmodifiableSortedMap(@Nullable
                                                                                                                                                                Collection<? extends Map.Entry<KEYTYPE,VALUETYPE>> aCollection)

newSet

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

newSet

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

newSet

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

newSet

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

newSet

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

newSet

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

newSet

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

newSet

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

newEnumSet

@Nonnull
 @ReturnsMutableCopy
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)

newBooleanSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Boolean> newBooleanSet(@Nullable
                                                                         boolean... aValues)

newByteSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Byte> newByteSet(@Nullable
                                                                   byte... aValues)

newCharSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Character> newCharSet(@Nullable
                                                                        char... aValues)

newDoubleSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Double> newDoubleSet(@Nullable
                                                                       double... aValues)

newFloatSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Float> newFloatSet(@Nullable
                                                                     float... aValues)

newIntSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Integer> newIntSet(@Nullable
                                                                     int... aValues)

newLongSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Long> newLongSet(@Nullable
                                                                   long... aValues)

newShortSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Short> newShortSet(@Nullable
                                                                     short... aValues)

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet()

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet(@Nullable
                                                                                                    ELEMENTTYPE aValue)

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet(@Nullable
                                                                                                    ELEMENTTYPE... aValues)

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet(@Nullable
                                                                                                    Iterable<? extends ELEMENTTYPE> aCont)

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet(@Nullable
                                                                                                    Collection<? extends ELEMENTTYPE> aCont)

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet(@Nullable
                                                                                                    Iterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet(@Nullable
                                                                                                    IIterableIterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableSet(@Nullable
                                                                                                    Enumeration<? extends ELEMENTTYPE> aEnum)

newUnmodifiableBooleanSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Boolean> newUnmodifiableBooleanSet(@Nullable
                                                                                         boolean... aValues)

newUnmodifiableByteSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Byte> newUnmodifiableByteSet(@Nullable
                                                                                   byte... aValues)

newUnmodifiableCharSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Character> newUnmodifiableCharSet(@Nullable
                                                                                        char... aValues)

newUnmodifiableDoubleSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Double> newUnmodifiableDoubleSet(@Nullable
                                                                                       double... aValues)

newUnmodifiableFloatSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Float> newUnmodifiableFloatSet(@Nullable
                                                                                     float... aValues)

newUnmodifiableIntSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Integer> newUnmodifiableIntSet(@Nullable
                                                                                     int... aValues)

newUnmodifiableLongSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Long> newUnmodifiableLongSet(@Nullable
                                                                                   long... aValues)

newUnmodifiableShortSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Short> newUnmodifiableShortSet(@Nullable
                                                                                     short... aValues)

newSortedSet

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

newSortedSet

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

newSortedSet

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

newSortedSet

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

newSortedSet

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

newSortedSet

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

newSortedSet

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

newSortedSet

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

newBooleanSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Boolean> newBooleanSortedSet(@Nullable
                                                                                   boolean... aValues)

newByteSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Byte> newByteSortedSet(@Nullable
                                                                             byte... aValues)

newCharSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Character> newCharSortedSet(@Nullable
                                                                                  char... aValues)

newDoubleSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Double> newDoubleSortedSet(@Nullable
                                                                                 double... aValues)

newFloatSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Float> newFloatSortedSet(@Nullable
                                                                               float... aValues)

newIntSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Integer> newIntSortedSet(@Nullable
                                                                               int... aValues)

newLongSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Long> newLongSortedSet(@Nullable
                                                                             long... aValues)

newShortSortedSet

@Nonnull
 @ReturnsMutableCopy
public static TreeSet<Short> newShortSortedSet(@Nullable
                                                                               short... aValues)

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet()

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet(@Nullable
                                                                                                                                                        ELEMENTTYPE aValue)

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet(@Nullable
                                                                                                                                                        ELEMENTTYPE... aValues)

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet(@Nullable
                                                                                                                                                        Iterable<? extends ELEMENTTYPE> aCont)

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet(@Nullable
                                                                                                                                                        Collection<? extends ELEMENTTYPE> aCont)

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet(@Nullable
                                                                                                                                                        Iterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet(@Nullable
                                                                                                                                                        IIterableIterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableSortedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> SortedSet<ELEMENTTYPE> newUnmodifiableSortedSet(@Nullable
                                                                                                                                                        Enumeration<? extends ELEMENTTYPE> aEnum)

newUnmodifiableBooleanSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Boolean> newUnmodifiableBooleanSortedSet(@Nullable
                                                                                                     boolean... aValues)

newUnmodifiableByteSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Byte> newUnmodifiableByteSortedSet(@Nullable
                                                                                               byte... aValues)

newUnmodifiableCharSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Character> newUnmodifiableCharSortedSet(@Nullable
                                                                                                    char... aValues)

newUnmodifiableDoubleSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Double> newUnmodifiableDoubleSortedSet(@Nullable
                                                                                                   double... aValues)

newUnmodifiableFloatSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Float> newUnmodifiableFloatSortedSet(@Nullable
                                                                                                 float... aValues)

newUnmodifiableIntSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Integer> newUnmodifiableIntSortedSet(@Nullable
                                                                                                 int... aValues)

newUnmodifiableLongSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Long> newUnmodifiableLongSortedSet(@Nullable
                                                                                               long... aValues)

newUnmodifiableShortSortedSet

@Nonnull
 @ReturnsImmutableObject
public static SortedSet<Short> newUnmodifiableShortSortedSet(@Nullable
                                                                                                 short... aValues)

newOrderedSet

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

newOrderedSet

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

newOrderedSet

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

newOrderedSet

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

newOrderedSet

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

newOrderedSet

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

newOrderedSet

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

newOrderedSet

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

newBooleanOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Boolean> newBooleanOrderedSet(@Nullable
                                                                                boolean... aValues)

newByteOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Byte> newByteOrderedSet(@Nullable
                                                                          byte... aValues)

newCharOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Character> newCharOrderedSet(@Nullable
                                                                               char... aValues)

newDoubleOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Double> newDoubleOrderedSet(@Nullable
                                                                              double... aValues)

newFloatOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Float> newFloatOrderedSet(@Nullable
                                                                            float... aValues)

newIntOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Integer> newIntOrderedSet(@Nullable
                                                                            int... aValues)

newLongOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Long> newLongOrderedSet(@Nullable
                                                                          long... aValues)

newShortOrderedSet

@Nonnull
 @ReturnsMutableCopy
public static Set<Short> newShortOrderedSet(@Nullable
                                                                            short... aValues)

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet()

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet(@Nullable
                                                                                                           ELEMENTTYPE aValue)

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet(@Nullable
                                                                                                           ELEMENTTYPE... aValues)

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet(@Nonnull
                                                                                                           Iterable<? extends ELEMENTTYPE> aCont)

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet(@Nonnull
                                                                                                           Collection<? extends ELEMENTTYPE> aCont)

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet(@Nonnull
                                                                                                           Iterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet(@Nonnull
                                                                                                           IIterableIterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> Set<ELEMENTTYPE> newUnmodifiableOrderedSet(@Nullable
                                                                                                           Enumeration<? extends ELEMENTTYPE> aEnum)

newUnmodifiableBooleanOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Boolean> newUnmodifiableBooleanOrderedSet(@Nullable
                                                                                                boolean... aValues)

newUnmodifiableByteOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Byte> newUnmodifiableByteOrderedSet(@Nullable
                                                                                          byte... aValues)

newUnmodifiableCharOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Character> newUnmodifiableCharOrderedSet(@Nullable
                                                                                               char... aValues)

newUnmodifiableDoubleOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Double> newUnmodifiableDoubleOrderedSet(@Nullable
                                                                                              double... aValues)

newUnmodifiableFloatOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Float> newUnmodifiableFloatOrderedSet(@Nullable
                                                                                            float... aValues)

newUnmodifiableIntOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Integer> newUnmodifiableIntOrderedSet(@Nullable
                                                                                            int... aValues)

newUnmodifiableLongOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Long> newUnmodifiableLongOrderedSet(@Nullable
                                                                                          long... aValues)

newUnmodifiableShortOrderedSet

@Nonnull
 @ReturnsImmutableObject
public static Set<Short> newUnmodifiableShortOrderedSet(@Nullable
                                                                                            short... aValues)

newListPrefilled

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

newList

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

newList

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

newList

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

newList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> List<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 ArrayList.
See Also:: Collections.list(Enumeration)

newList

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

newList

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

newList

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

newList

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

newVectorPrefilled

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

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector()

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector(@Nullable
                                                                                          ELEMENTTYPE aValue)

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector(@Nullable
                                                                                          ELEMENTTYPE... aValues)

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector(@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 Vector.
See Also:: Collections.list(Enumeration)

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector(@Nullable
                                                                                          Iterator<? extends ELEMENTTYPE> aIter)

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector(@Nullable
                                                                                          Iterable<? extends ELEMENTTYPE> aIter)

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector(@Nullable
                                                                                          Collection<? extends ELEMENTTYPE> aCont)

newVector

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Vector<ELEMENTTYPE> newVector(@Nullable
                                                                                          IIterableIterator<? extends ELEMENTTYPE> aIter)

newBooleanList

@Nonnull
 @ReturnsMutableCopy
public static List<Boolean> newBooleanList(@Nullable
                                                                           boolean... aValues)

newByteList

@Nonnull
 @ReturnsMutableCopy
public static List<Byte> newByteList(@Nullable
                                                                     byte... aValues)

newCharList

@Nonnull
 @ReturnsMutableCopy
public static List<Character> newCharList(@Nullable
                                                                          char... aValues)

newDoubleList

@Nonnull
 @ReturnsMutableCopy
public static List<Double> newDoubleList(@Nullable
                                                                         double... aValues)

newFloatList

@Nonnull
 @ReturnsMutableCopy
public static List<Float> newFloatList(@Nullable
                                                                       float... aValues)

newIntList

@Nonnull
 @ReturnsMutableCopy
public static List<Integer> newIntList(@Nullable
                                                                       int... aValues)

newLongList

@Nonnull
 @ReturnsMutableCopy
public static List<Long> newLongList(@Nullable
                                                                     long... aValues)

newShortList

@Nonnull
 @ReturnsMutableCopy
public static List<Short> newShortList(@Nullable
                                                                       short... aValues)

newBooleanVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Boolean> newBooleanVector(@Nullable
                                                                               boolean... aValues)

newByteVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Byte> newByteVector(@Nullable
                                                                         byte... aValues)

newCharVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Character> newCharVector(@Nullable
                                                                              char... aValues)

newDoubleVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Double> newDoubleVector(@Nullable
                                                                             double... aValues)

newFloatVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Float> newFloatVector(@Nullable
                                                                           float... aValues)

newIntVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Integer> newIntVector(@Nullable
                                                                           int... aValues)

newLongVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Long> newLongVector(@Nullable
                                                                         long... aValues)

newShortVector

@Nonnull
 @ReturnsMutableCopy
public static Vector<Short> newShortVector(@Nullable
                                                                           short... aValues)

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList()

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList(@Nullable
                                                                                                      ELEMENTTYPE aValue)

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList(@Nullable
                                                                                                      ELEMENTTYPE... aValues)

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList(@Nullable
                                                                                                      Enumeration<? extends ELEMENTTYPE> aIter)

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList(@Nullable
                                                                                                      Iterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList(@Nullable
                                                                                                      Iterable<? extends ELEMENTTYPE> aCont)

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList(@Nullable
                                                                                                      Collection<? extends ELEMENTTYPE> aCont)

newUnmodifiableList

@Nonnull
 @ReturnsImmutableObject
public static <ELEMENTTYPE> List<ELEMENTTYPE> newUnmodifiableList(@Nullable
                                                                                                      IIterableIterator<? extends ELEMENTTYPE> aIter)

newUnmodifiableBooleanList

@Nonnull
 @ReturnsImmutableObject
public static List<Boolean> newUnmodifiableBooleanList(@Nullable
                                                                                           boolean... aValues)

newUnmodifiableByteList

@Nonnull
 @ReturnsImmutableObject
public static List<Byte> newUnmodifiableByteList(@Nullable
                                                                                     byte... aValues)

newUnmodifiableCharList

@Nonnull
 @ReturnsImmutableObject
public static List<Character> newUnmodifiableCharList(@Nullable
                                                                                          char... aValues)

newUnmodifiableDoubleList

@Nonnull
 @ReturnsImmutableObject
public static List<Double> newUnmodifiableDoubleList(@Nullable
                                                                                         double... aValues)

newUnmodifiableFloatList

@Nonnull
 @ReturnsImmutableObject
public static List<Float> newUnmodifiableFloatList(@Nullable
                                                                                       float... aValues)

newUnmodifiableIntList

@Nonnull
 @ReturnsImmutableObject
public static List<Integer> newUnmodifiableIntList(@Nullable
                                                                                       int... aValues)

newUnmodifiableLongList

@Nonnull
 @ReturnsImmutableObject
public static List<Long> newUnmodifiableLongList(@Nullable
                                                                                     long... aValues)

newUnmodifiableShortList

@Nonnull
 @ReturnsImmutableObject
public static List<Short> newUnmodifiableShortList(@Nullable
                                                                                       short... aValues)

newStack

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE> newStack()

newStack

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE> newStack(@Nullable
                                                                                                   ELEMENTTYPE aValue)

Create a new stack with a single element.

Type Parameters:: ELEMENTTYPE - The type of elements contained in the stack.
Parameters:: aValue - The value to push. Maybe null.
Returns:: A non-null stack.

newStack

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE> newStack(@Nullable
                                                                                                   ELEMENTTYPE... aValues)

Create a new stack from the given array.

Type Parameters:: ELEMENTTYPE - The type of elements contained in the stack.
Parameters:: aValues - The values that are to be pushed on the stack. The last element will be the top element on the stack. May not be null .
Returns:: A non-null stack object.

newStack

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE> newStack(@Nullable
                                                                                                   Collection<? extends ELEMENTTYPE> aValues)

Create a new stack from the given collection.

Type Parameters:: ELEMENTTYPE - The type of elements contained in the stack.
Parameters:: aValues - The values that are to be pushed on the stack. The last element will be the top element on the stack. May not be null .
Returns:: A non-null stack object.

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue()

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue(@Nonnull
                                                                                        ELEMENTTYPE aValue)

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue(@Nullable
                                                                                        ELEMENTTYPE... aValues)

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue(@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 PriorityQueue.
See Also:: Collections.list(Enumeration)

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue(@Nullable
                                                                                        Iterator<? extends ELEMENTTYPE> aIter)

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue(@Nullable
                                                                                        Iterable<? extends ELEMENTTYPE> aIter)

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue(@Nullable
                                                                                        Collection<? extends ELEMENTTYPE> aCont)

newQueue

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> Queue<ELEMENTTYPE> newQueue(@Nullable
                                                                                        IIterableIterator<? extends ELEMENTTYPE> aIter)

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<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 ArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<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 ArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<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 ArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> List<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 ArrayList based on the results of Collections.sort(List, Comparator).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<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 ArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> List<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 ArrayList based on the results of Collections.sort(List, Comparator).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<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 ArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> List<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 ArrayList based on the results of Collections.sort(List, Comparator).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<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 ArrayList based on the results of Collections.sort(List).

getSorted

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> List<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 ArrayList based on the results of Collections.sort(List, Comparator).

getSortedInline

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

getSortedInline

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

getSortedByKey

@Nullable
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> Map<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 or the original map, if it was empty

getSortedByKey

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

Get a map sorted by its 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; eSortOrder - The sort oder to use for sorting. May not be null.
Returns:: the sorted map or the original map, if it was empty

getSortedByKey

@Nullable
public static <KEYTYPE,VALUETYPE> Map<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 or the original map, if it was empty

getSortedByValue

@Nullable
public static <KEYTYPE,VALUETYPE extends Comparable<? super VALUETYPE>> Map<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 or the original map, if it was empty

getSortedByValue

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

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.; eSortOrder - The sort order to be applied. May not be null.
Returns:: the sorted map or the original map, if it was empty

getSortedByValue

@Nullable
public static <KEYTYPE,VALUETYPE> Map<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 or the original map, if it was empty

getReverseList

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

getReverseInlineList

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

getIterator

@Nonnull
public static <ELEMENTTYPE> IIterableIterator<ELEMENTTYPE> getIterator(@Nullable
                                                                                 Enumeration<? extends ELEMENTTYPE> aEnum)

getIterator

@Nonnull
public static <ELEMENTTYPE> Iterator<ELEMENTTYPE> getIterator(@Nullable
                                                                        Iterable<ELEMENTTYPE> aCont)

getIterator

@Nonnull
public static <ELEMENTTYPE> Iterator<ELEMENTTYPE> getIterator(@Nullable
                                                                        Iterator<ELEMENTTYPE> aIter)

getIterator

@Nonnull
public static <ELEMENTTYPE> Iterator<ELEMENTTYPE> getIterator(@Nullable
                                                                        ELEMENTTYPE... aArray)

getReverseIterator

@Nonnull
public static <ELEMENTTYPE> Iterator<ELEMENTTYPE> getReverseIterator(@Nullable
                                                                               List<? extends ELEMENTTYPE> aCont)

getEmptyIterator
```
@Nonnull
public static <ELEMENTTYPE> Iterator<ELEMENTTYPE> getEmptyIterator()
```
Create an empty iterator.

Type Parameters:

ELEMENTTYPE - The type the iterator's elements.

Returns:

A non-null object.

getCombinedIterator

@Nonnull
public static <ELEMENTTYPE> Iterator<ELEMENTTYPE> getCombinedIterator(@Nullable
                                                                                Iterator<? extends ELEMENTTYPE> aIter1,
                                                                                @Nullable
                                                                                Iterator<? extends ELEMENTTYPE> aIter2)

Get a merged iterator of both iterators. The first iterator is iterated first, the second one afterwards.

Type Parameters:: ELEMENTTYPE - The type of elements to be enumerated.
Parameters:: aIter1 - First iterator. May be null.; aIter2 - Second iterator. May be null.
Returns:: The merged iterator. Never null.

getEnumeration

@Nonnull
public static <ELEMENTTYPE> Enumeration<ELEMENTTYPE> getEnumeration(@Nullable
                                                                              Iterable<ELEMENTTYPE> aCont)

Get an Enumeration object based on a Collection object.

Type Parameters:: ELEMENTTYPE - the type of the elements in the container
Parameters:: aCont - The container to enumerate.
Returns:: an Enumeration object

getEnumeration

@Nonnull
public static <ELEMENTTYPE> Enumeration<ELEMENTTYPE> getEnumeration(@Nullable
                                                                              ELEMENTTYPE... aArray)

Get an Enumeration object based on the passed array.

Type Parameters:: ELEMENTTYPE - the type of the elements in the container
Parameters:: aArray - The array to enumerate.
Returns:: an Enumeration object

getEnumeration

@Nonnull
public static <ELEMENTTYPE> Enumeration<ELEMENTTYPE> getEnumeration(@Nullable
                                                                              Iterator<ELEMENTTYPE> aIter)

Get an Enumeration object based on an Iterator object.

Type Parameters:: ELEMENTTYPE - the type of the elements in the container
Parameters:: aIter - iterator object to use
Returns:: an Enumeration object

getEnumeration

@Nonnull
public static <KEYTYPE,VALUETYPE> Enumeration<Map.Entry<KEYTYPE,VALUETYPE>> getEnumeration(@Nullable
                                                                                                     Map<KEYTYPE,VALUETYPE> aMap)

Get an Enumeration object based on a Map object.

Type Parameters:: KEYTYPE - map key type; VALUETYPE - map value type
Parameters:: aMap - map object to use
Returns:: an Enumeration object

getEmptyEnumeration
```
@Nonnull
public static <ELEMENTTYPE> Enumeration<ELEMENTTYPE> getEmptyEnumeration()
```
Create an empty enumeration.

Type Parameters:

ELEMENTTYPE - The type the enumeration's elements.

Returns:

A non-null object.

getStackCopyWithoutTop

@Nullable
 @ReturnsMutableCopy
public static <ELEMENTTYPE> NonBlockingStack<ELEMENTTYPE> getStackCopyWithoutTop(@Nullable
                                                                                                                  NonBlockingStack<ELEMENTTYPE> aStack)

getFilteredMap

@Nullable
 @ReturnsMutableCopy
public static <KEY,VALUE> Map<KEY,VALUE> getFilteredMap(@Nullable
                                                                                         Map<KEY,VALUE> aValues,
                                                                                         @Nullable
                                                                                         Collection<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
                                                                   SortedSet<ELEMENTTYPE> aSortedSet)

Get the first element of the passed sorted set.

Type Parameters:: ELEMENTTYPE - Set element type
Parameters:: aSortedSet - The sorted set. 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.

getFirstElement

@Nullable
public static <KEYTYPE,VALUETYPE> Map.Entry<KEYTYPE,VALUETYPE> getFirstElement(@Nullable
                                                                                          Map<KEYTYPE,VALUETYPE> aMap)

Get the first element of the passed map.

Type Parameters:: KEYTYPE - Map key type; VALUETYPE - Map value type
Parameters:: aMap - The map. May be null.
Returns:: null if the map is null or empty, the first element otherwise.

getFirstKey

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

Get the first key of the passed map.

Type Parameters:: KEYTYPE - Map key type; VALUETYPE - Map value type
Parameters:: aMap - The map. May be null.
Returns:: null if the map is null or empty, the first key otherwise.

getFirstKey

@Nullable
public static <KEYTYPE,VALUETYPE> KEYTYPE getFirstKey(@Nullable
                                                                 SortedMap<KEYTYPE,VALUETYPE> aSortedMap)

Get the first key of the passed sorted map.

Type Parameters:: KEYTYPE - Map key type; VALUETYPE - Map value type
Parameters:: aSortedMap - The sorted map. May be null.
Returns:: null if the map is null or empty, the first key otherwise.

getFirstValue

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

Get the first value of the passed map.

Type Parameters:: KEYTYPE - Map key type; VALUETYPE - Map value type
Parameters:: aMap - The map. May be null.
Returns:: null if the map is null or empty, the first value otherwise.

getFirstValue

@Nullable
public static <KEYTYPE,VALUETYPE> VALUETYPE getFirstValue(@Nullable
                                                                     SortedMap<KEYTYPE,VALUETYPE> aSortedMap)

Get the first value of the passed map.

Type Parameters:: KEYTYPE - Map key type; VALUETYPE - Map value type
Parameters:: aSortedMap - The map. May be null.
Returns:: null if the map is null or empty, the first value 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
                                                                  SortedSet<ELEMENTTYPE> aSortedSet)

getLastElement

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

getLastElement

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

removeElementAtIndex
```
@Nonnull
public static EChange removeElementAtIndex(@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:

removeElementAtIndex(List, int)

getLastKey

@Nullable
public static <KEYTYPE,VALUETYPE> KEYTYPE getLastKey(@Nullable
                                                                SortedMap<KEYTYPE,VALUETYPE> aSortedMap)

Get the last key of the passed sorted map.

Type Parameters:: KEYTYPE - Map key type; VALUETYPE - Map value type
Parameters:: aSortedMap - The sorted map. May be null.
Returns:: null if the map is null or empty, the last key otherwise.

getLastValue

@Nullable
public static <KEYTYPE,VALUETYPE> VALUETYPE getLastValue(@Nullable
                                                                    SortedMap<KEYTYPE,VALUETYPE> aSortedMap)

Get the last value of the passed map.

Type Parameters:: KEYTYPE - Map key type; VALUETYPE - Map value type
Parameters:: aSortedMap - The map. May be null.
Returns:: null if the map is null or empty, the last value otherwise.

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
                              Iterator<?> aIter)

isEmpty

public static boolean isEmpty(@Nullable
                              IIterableIterator<?> aIter)

isEmpty

public static boolean isEmpty(@Nullable
                              Enumeration<?> aEnum)

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
                                 Iterator<?> aIter)

isNotEmpty

public static boolean isNotEmpty(@Nullable
                                 IIterableIterator<?> aIter)

isNotEmpty

public static boolean isNotEmpty(@Nullable
                                 Enumeration<?> aEnum)

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.

getSize
```
@Nonnegative
public static int getSize(@Nullable
                                        IIterableIterator<?> aIterator)
```
Retrieve the size of the passed Iterable.

Parameters:

aIterator - Iterable iterator to check. May be null.

Returns:

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

getSize
```
@Nonnegative
public static int getSize(@Nullable
                                        Iterator<?> aIterator)
```
Retrieve the size of the passed Iterator.

Parameters:

aIterator - Iterator to check. May be null.

Returns:

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

getSize
```
@Nonnegative
public static int getSize(@Nullable
                                        Enumeration<?> aEnumeration)
```
Retrieve the size of the passed Enumeration.

Parameters:

aEnumeration - Enumeration to check. May be null.

Returns:

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

getConcatenatedList

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

getConcatenatedList

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

getConcatenatedList

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

getConcatenatedSet

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

getConcatenatedSet

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

getConcatenatedSet

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

getConcatenatedInline

@Nonnull
 @ReturnsMutableObject(value="design")
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> Map<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 List<Boolean> newObjectListFromArray(@Nullable
                                                                                    boolean[] aArray)

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static List<Byte> newObjectListFromArray(@Nullable
                                                                                 byte[] aArray)

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static List<Character> newObjectListFromArray(@Nullable
                                                                                      char[] aArray)

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static List<Double> newObjectListFromArray(@Nullable
                                                                                   double[] aArray)

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static List<Float> newObjectListFromArray(@Nullable
                                                                                  float[] aArray)

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static List<Integer> newObjectListFromArray(@Nullable
                                                                                    int[] aArray)

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static List<Long> newObjectListFromArray(@Nullable
                                                                                 long[] aArray)

newObjectListFromArray

@Nullable
 @ReturnsMutableCopy
public static List<Short> newObjectListFromArray(@Nullable
                                                                                  short[] aArray)

newObjectListFromArray

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

getSubList

@Nonnull
 @ReturnsMutableCopy
public static <ELEMENTTYPE> List<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.

getSwappedKeyValues

@Nullable
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> Map<VALUETYPE,KEYTYPE> getSwappedKeyValues(@Nullable
                                                                                                              Map<KEYTYPE,VALUETYPE> aMap)

Get a map where keys and values are exchanged.

Type Parameters:: KEYTYPE - Original key type.; VALUETYPE - Original value type.
Parameters:: aMap - The input map to convert. May not be null.
Returns:: The swapped hash map (unsorted!)

getReverseLookupSet

@Nullable
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> IMultiMapSetBased<VALUETYPE,KEYTYPE> getReverseLookupSet(@Nullable
                                                                                                                            IMultiMap<KEYTYPE,VALUETYPE,? extends Collection<VALUETYPE>> aMap)

Get a map where the lookup (1K..nV) has been reversed to (1V..nK)

Type Parameters:: KEYTYPE - Original key type; VALUETYPE - Original value type
Parameters:: aMap - The input map to convert. May not be null
Returns:: A swapped IMultiMapSetBased

getReverseLookup

@Nullable
 @ReturnsMutableCopy
public static <KEYTYPE,VALUETYPE> IMultiMapSetBased<VALUETYPE,KEYTYPE> getReverseLookup(@Nullable
                                                                                                                         IMultiMapSetBased<KEYTYPE,VALUETYPE> aMap)

Get a map where the lookup (1K..nV) has been reversed to (1V..nK)

Type Parameters:: KEYTYPE - Original key type; VALUETYPE - Original value type
Parameters:: aMap - The input map to convert. May not be null
Returns:: A swapped HashMap

getSafe

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getSafe(@Nullable
                                                           List<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.

getSafe

@Nullable
public static <ELEMENTTYPE> ELEMENTTYPE getSafe(@Nullable
                                                           List<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.

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.

Class CollectionHelper

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getCollectionBaseTypeOfClass

getCollectionBaseTypeOfObject

isCollectionClass

isCollectionObject

getAsList

getNotNull

getNotNull

getNotNull

getNotNull

getNotNull

makeUnmodifiable

makeUnmodifiable

makeUnmodifiable

makeUnmodifiable

makeUnmodifiable

makeUnmodifiable

makeUnmodifiableNotNull

makeUnmodifiableNotNull

makeUnmodifiableNotNull

makeUnmodifiableNotNull

makeUnmodifiableNotNull

makeUnmodifiableNotNull

getDifference

getIntersected

newMap

newMap

newMap

newMap

newMap

newMap

newMap

newMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newSet

newSet

newSet

newSet