ContainerHelper (phloc-commons 4.3.3 API)

java.lang.Object
- com.phloc.commons.collections.ContainerHelper

```
@Immutable
public final class ContainerHelper
extends Object
```
Provides various helper methods to handle collections like List, Set and Map.

Author:

Philip Helger

Method Summary

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 <ELEMENTTYPE> Enumeration<ELEMENTTYPE>`	`getCombinedEnumeration(Enumeration<? extends ELEMENTTYPE> aEnum1, Enumeration<? extends ELEMENTTYPE> aEnum2)` Get a merged enumeration of both enumeration.
`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`	`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 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 <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 <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>`	`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 <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(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

getNotNull

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

getNotNull

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

getNotNull

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

getNotNull

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

getNotNull

@Nonnull
public static <KEYTYPE extends Comparable<? super KEYTYPE>,VALUETYPE> SortedMap<? extends KEYTYPE,? extends VALUETYPE> getNotNull(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.

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.

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
                                                                           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
                                                                                           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
                                                                                  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
                                                                                                  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
                                                                                                                         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
                                                                                                                                           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(reason="design")
public static <ELEMENTTYPE extends Comparable<? super ELEMENTTYPE>> List<ELEMENTTYPE> getSortedInline(@Nullable
                                                                                                                          List<ELEMENTTYPE> aList)

getSortedInline

@Nullable
@ReturnsMutableObject(reason="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(reason="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

getCombinedEnumeration

@Nonnull
public static <ELEMENTTYPE> Enumeration<ELEMENTTYPE> getCombinedEnumeration(@Nullable
                                                                    Enumeration<? extends ELEMENTTYPE> aEnum1,
                                                                    @Nullable
                                                                    Enumeration<? extends ELEMENTTYPE> aEnum2)

Get a merged enumeration of both enumeration. The first enumeration is enumerated first, the second one afterwards.

Type Parameters:: ELEMENTTYPE - The type of elements to be enumerated.
Parameters:: aEnum1 - First enumeration. May be null.; aEnum2 - Second enumeration. May be null.
Returns:: The merged enumeration. Never null.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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()

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.

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.

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(reason="design")
public static <ELEMENTTYPE,COLLTYPE extends Collection<? super ELEMENTTYPE>> COLLTYPE getConcatenatedInline(@Nonnull
                                                                                                                               COLLTYPE aCont,
                                                                                                                               @Nullable
                                                                                                                               ELEMENTTYPE... aElementsToAdd)

getConcatenatedInline

@Nonnull
@ReturnsMutableObject(reason="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 ContainerHelper

Method Summary

Methods inherited from class java.lang.Object

Method Detail

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

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newUnmodifiableMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newUnmodifiableOrderedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newUnmodifiableSortedMap

newSet

newSet

newSet

newSet

newSet

newSet

newSet

newSet

newEnumSet

newEnumSet

newEnumSet

newBooleanSet

newByteSet

newCharSet

newDoubleSet