CollectionHelpers (McIDAS-V 1.5 Developer Documentation)

java.lang.Object
- edu.wisc.ssec.mcidasv.util.CollectionHelpers

```
public final class CollectionHelpers
extends Object
```
A collection (ugh) of static methods that make working with Java's default collections a bit easier, or at least allows you to elide some of the redundancy of idiomatic Java.
Make use of "static imports" to omit even more needless code.

Constructor Summary

Constructors
Modifier Constructor and Description

private CollectionHelpers()
Never!

Constructors
Modifier	Constructor and Description
`private`	`CollectionHelpers()` Never!

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> T[]`	`arr(T... ts)` "Converts" the incoming "varargs" into an array.
`static <E> List<E>`	`arrList()` Creates an empty `ArrayList` that uses a little cleverness with Java's generics.
`static <E> List<E>`	`arrList(Collection<? extends E> c)` Copies an existing `Collection` into a new `ArrayList`.
`static <E> List<E>`	`arrList(int capacity)` Creates an empty `ArrayList` with a given capacity.
`static <E> Collection<E>`	`collect(Class<? extends Collection> cl, E... elements)` Creates a new `cl` instance (limited to things implementing `Collection`) populated with the "varargs".
`static <E> List<E>`	`concurrentList()` Creates an empty `CopyOnWriteArrayList`.
`static <E> List<E>`	`concurrentList(Collection<E> original)` Creates a new `CopyOnWriteArrayList` that contains all of the elements in `original`.
`static <E> List<E>`	`concurrentList(E... elems)` Creates a new `CopyOnWriteArrayList` from the incoming "varargs".
`static <K,V> Map<K,V>`	`concurrentMap()` Abuses Java's sad "type" implementation to create a new `ConcurrentHashMap`.
`static <E> Set<E>`	`concurrentSet()` Creates a new `CopyOnWriteArraySet`.
`static <E> Set<E>`	`concurrentSet(Collection<E> original)` Creates a new `CopyOnWriteArraySet` that contains all of the elements in `original`.
`static <E> Set<E>`	`concurrentSet(E... elems)` Creates a new `CopyOnWriteArraySet` from the incoming "varargs".
`static boolean`	`contains(Object collection, Object item)` Searches an object to see if it "contains" another object.
`static int`	`len(Object o)` Determines the "length" of a given object.
`static <E> List<E>`	`linkedList()`
`static <E> List<E>`	`linkedList(Collection<? extends E> c)`
`static <E> List<E>`	`list(E... elements)` Creates a `List` from incoming "varargs".
`static <A,B> List<B>`	`map(Function<A,B> f, List<A> as)` Applies a given function to each item in a given list.
`static <A,B> Set<B>`	`map(Function<A,B> f, Set<A> as)` Applies a given function to each item in a given `Set`.
`static <E> Set<E>`	`newHashSet()` Creates an empty `HashSet` that uses a little cleverness with Java's generics.
`static <E> Set<E>`	`newHashSet(Collection<E> original)` Copies an existing `Collection` into a new `HashSet`.
`static <E> Set<E>`	`newHashSet(int initialCapacity)` Creates an empty `HashSet` with a given initial capacity.
`static <K,V> Map<K,V>`	`newLinkedHashMap()` Creates an empty `LinkedHashMap` that uses a little cleverness with Java's generics.
`static <K,V> Map<K,V>`	`newLinkedHashMap(int initialCapacity)` Creates an empty `LinkedHashMap` with a given initial capacity.
`static <K,V> Map<K,V>`	`newLinkedHashMap(Map<K,V> original)` Copies an existing `Map` into a new `LinkedHashMap`.
`static <E> Set<E>`	`newLinkedHashSet()` Creates an empty `LinkedHashSet` that uses a little cleverness with Java's generics.
`static <E> Set<E>`	`newLinkedHashSet(Collection<E> original)` Copies a `Collection` into a new `LinkedHashSet`.
`static <E> Set<E>`	`newLinkedHashSet(int initialCapacity)` Creates an empty `LinkedHashSet` with a given initial capacity.
`static <K,V> Map<K,V>`	`newMap()` Creates an empty `HashSet` that uses a little cleverness with Java's generics.
`static <K,V> Map<K,V>`	`newMap(int initialCapacity)` Creates an empty `HashSet` with a given initial capacity.
`static <K,V> Map<K,V>`	`newMap(Map<K,V> original)` Copies an existing `Map` into a new `HashMap`.
`static <E> Collection<E>`	`recollect(Class<? extends Collection> cl, Collection<E> old)` Copies an existing `Collection` into a new (non-abstract!)
`static <E> Set<E>`	`set(E... elements)` Creates a `Set` from incoming "varargs".
`static <K,V> Map<K,V>`	`zipMap(Collection<? extends K> keys, Collection<? extends V> values)` A version of `zipMap(Object[], Object[])` that works with `Collection`s.
`static <K,V> Map<K,V>`	`zipMap(K[] keys, V[] values)` Takes arrays of `keys` and `values` and merges them together to form a `Map`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - CollectionHelpers
```
private CollectionHelpers()
```
    Never!
- Method Detail
  - arr
```
public static <T> T[] arr(T... ts)
```
    "Converts" the incoming "varargs" into an array.
    Useful for doing things like: String[] strs = arr("hello", "how", "are", "you?");
    
    Parameters:
    ts - Items that will make up the elements of the returned array. Cannot be null, and (for now) the items should be of the same type.
    
    Returns:
    An array populated with each item from ts.
  - list
```
public static <E> List<E> list(E... elements)
```
    Creates a List from incoming "varargs". Currently uses ArrayList as the List implementation.
    Used like so: List<String> listy = list("y", "helo", "thar");
    
    Parameters:
    elements - Items that will make up the elements of the returned List.
    
    Returns:
    A List whose elements are each item within elements.
  - set
```
public static <E> Set<E> set(E... elements)
```
    Creates a Set from incoming "varargs". Currently uses LinkedHashSet as the Set implementation (to preserve ordering).
    Used like so:
```
 for (String s : set("beep", "boop", "blorp")) { ... }
```
    Parameters:
    elements - Items that will appear within the returned Set. Cannot be null, and (for now) the items should be of the same type.
    
    Returns:
    A Set containing the items in elements. Remember that Sets only contain unique elements!
  - collect
```
public static <E> Collection<E> collect(Class<? extends Collection> cl,
                        E... elements)
```
    Creates a new cl instance (limited to things implementing Collection) populated with the "varargs". Useful if you truly despise arr(Object...), list(Object...), or set(Object...).
    Example: Collection<Integer> ints = collect(PriorityBlockingQueue.class, 1, 2, 3);
    
    Parameters:
    cl - A (non-abstract!) class that implements Collection. Cannot be null.
    elements - Objects that will be added to the collection.
    
    Returns:
    An instance of cl containing the given objects.
    
    Throws:
    
    RuntimeException - if Constructor#newInstance(Object...) had problems.
    See Also:
    arr(Object...), list(Object...), set(Object...)
  - len
```
public static int len(Object o)
```
    Determines the "length" of a given object. This method currently understands:
    More coming!
    Parameters:
    o - Object whose length we want. Cannot be null.
    
    Returns:
    "Length" of o.
    
    Throws:
    
    NullPointerException - if o is null.
    
    IllegalArgumentException - if the method doesn't know how to test whatever type of object o might be.
  - contains
```
public static boolean contains(Object collection,
               Object item)
```
    Searches an object to see if it "contains" another object. This method currently knows how to search:
    More coming!
    Parameters:
    collection - Object that will be searched for item. Cannot be null.
    item - Object to search for within o. null values are allowed.
    
    Returns:
    true if o contains item, false otherwise.
    
    Throws:
    
    NullPointerException - if o is null.
    
    IllegalArgumentException - if the method doesn't know how to search whatever type of object o might be.
  - newHashSet
```
public static <E> Set<E> newHashSet()
```
    Creates an empty HashSet that uses a little cleverness with Java's generics. Useful for eliminating redundant type information and declaring fields as final.
    Please consider using newHashSet(int) or newHashSet(java.util.Collection) instead of this method.
    
    Returns:
    A new, empty HashSet.
    See Also:
    newHashSet(int), newHashSet(java.util.Collection)
  - newHashSet
```
public static <E> Set<E> newHashSet(int initialCapacity)
```
    Creates an empty HashSet with a given initial capacity.
    
    Parameters:
    initialCapacity - Initial capacity of the HashSet. Cannot be negative.
    
    Returns:
    A new, empty HashSet with the given initial capacity.
  - newHashSet
```
public static <E> Set<E> newHashSet(Collection<E> original)
```
    Copies an existing Collection into a new HashSet.
    
    Parameters:
    original - Collection to be copied. Cannot be null.
    
    Returns:
    A new HashSet whose contents are the same as original.
  - newLinkedHashSet
```
public static <E> Set<E> newLinkedHashSet()
```
    Creates an empty LinkedHashSet that uses a little cleverness with Java's generics. Useful for eliminating redundant type information and declaring fields as final.
    Please consider using newLinkedHashSet(int) or newLinkedHashSet(java.util.Collection) instead of this method.
    
    Returns:
    A new, empty LinkedHashSet.
    See Also:
    newLinkedHashSet(int), newLinkedHashSet(java.util.Collection)
  - newLinkedHashSet
```
public static <E> Set<E> newLinkedHashSet(int initialCapacity)
```
    Creates an empty LinkedHashSet with a given initial capacity.
    
    Parameters:
    initialCapacity - Initial capacity of the LinkedHashSet. Cannot be negative.
    
    Returns:
    A new, empty LinkedHashSet with the given initial capacity.
  - newLinkedHashSet
```
public static <E> Set<E> newLinkedHashSet(Collection<E> original)
```
    Copies a Collection into a new LinkedHashSet.
    
    Parameters:
    original - Collection to be copied. Cannot be null.
    
    Returns:
    A new LinkedHashSet whose contents are the same as original.
  - newMap
```
public static <K,V> Map<K,V> newMap()
```
    Creates an empty HashSet that uses a little cleverness with Java's generics. Useful for eliminating redundant type information and declaring fields as final, while also reducing compiler warnings.
    Please consider using newMap(int) or newMap(java.util.Map) instead of this method.
    
    Returns:
    A new, empty HashMap.
    See Also:
    newMap(int), newMap(java.util.Map)
  - newMap
```
public static <K,V> Map<K,V> newMap(int initialCapacity)
```
    Creates an empty HashSet with a given initial capacity.
    
    Parameters:
    initialCapacity - Initial capacity of the HashMap. Cannot be negative.
    
    Returns:
    A new, empty HashMap with the given initial capacity.
  - newMap
```
public static <K,V> Map<K,V> newMap(Map<K,V> original)
```
    Copies an existing Map into a new HashMap.
    
    Parameters:
    original - Map to be copied. Cannot be null.
    
    Returns:
    A new HashMap whose contents are the same as original.
  - newLinkedHashMap
```
public static <K,V> Map<K,V> newLinkedHashMap()
```
    Creates an empty LinkedHashMap that uses a little cleverness with Java's generics. Useful for eliminating redundant type information and declaring fields as final, while also reducing compiler warnings.
    Please consider using newLinkedHashMap(int) or newLinkedHashSet(java.util.Collection) instead of this method.
    
    Returns:
    A new, empty LinkedHashMap.
    See Also:
    newLinkedHashMap(int), newLinkedHashMap(java.util.Map)
  - newLinkedHashMap
```
public static <K,V> Map<K,V> newLinkedHashMap(int initialCapacity)
```
    Creates an empty LinkedHashMap with a given initial capacity.
    
    Parameters:
    initialCapacity - Initial capacity of the LinkedHashMap. Cannot be negative.
    
    Returns:
    A new, empty LinkedHashMap with the given initial capacity.
  - newLinkedHashMap
```
public static <K,V> Map<K,V> newLinkedHashMap(Map<K,V> original)
```
    Copies an existing Map into a new LinkedHashMap.
    
    Parameters:
    original - Map to be copied. Cannot be null.
    
    Returns:
    A new LinkedHashMap whose contents are the same as original.
  - concurrentMap
```
public static <K,V> Map<K,V> concurrentMap()
```
    Abuses Java's sad "type" implementation to create a new ConcurrentHashMap.
    
    Returns:
    Shiny and new ConcurrentHashMap
  - concurrentList
```
public static <E> List<E> concurrentList()
```
    Creates an empty CopyOnWriteArrayList. Keep in mind that you only want to use CopyOnWriteArrayList for lists that are not going to be modified very often!
    
    Returns:
    A new, empty CopyOnWriteArrayList.
  - concurrentList
```
public static <E> List<E> concurrentList(Collection<E> original)
```
    Creates a new CopyOnWriteArrayList that contains all of the elements in original. Keep in mind that you only want to use CopyOnWriteArrayList for lists that are not going to be modified very often!
    
    Parameters:
    original - Collection to be copied into the new list.
    
    Returns:
    A new CopyOnWriteArrayList whose contents are the same as original.
  - concurrentList
```
public static <E> List<E> concurrentList(E... elems)
```
    Creates a new CopyOnWriteArrayList from the incoming "varargs". Keep in mind that you only want to use CopyOnWriteArrayList for lists that are not going to be modified very often!
    
    Parameters:
    elems - Elements that will be contained in the resulting list.
    
    Returns:
    A new CopyOnWriteArrayList that contains the incoming objects.
  - concurrentSet
```
public static <E> Set<E> concurrentSet()
```
    Creates a new CopyOnWriteArraySet. Keep in mind that you only want to use a CopyOnWriteArraySet for sets that are not going to be modified very often!
    
    Returns:
    A new, empty CopyOnWriteArraySet.
  - concurrentSet
```
public static <E> Set<E> concurrentSet(Collection<E> original)
```
    Creates a new CopyOnWriteArraySet that contains all of the elements in original. Keep in mind that you only want to use a CopyOnWriteArraySet for sets that are not going to be modified very often!
    
    Parameters:
    original - Collection to be copied into the new set.
    
    Returns:
    A new CopyOnWriteArraySet whose contents are the same as original.
  - concurrentSet
```
public static <E> Set<E> concurrentSet(E... elems)
```
    Creates a new CopyOnWriteArraySet from the incoming "varargs". Keep in mind that you only want to use a CopyOnWriteArraySet for sets that are not going to be modified very often!
    
    Parameters:
    elems - Elements that will be contained in the resulting set.
    
    Returns:
    A new CopyOnWriteArraySet that contains the incoming objects.
  - linkedList
```
public static <E> List<E> linkedList()
```
  - linkedList
```
public static <E> List<E> linkedList(Collection<? extends E> c)
```
  - arrList
```
public static <E> List<E> arrList()
```
    Creates an empty ArrayList that uses a little cleverness with Java's generics. Useful for eliminating redundant type information and declaring fields as final.
    Used like so: List<String> listy = arrList();
    Please consider using arrList(int) or arrList(java.util.Collection) instead of this method.
    
    Returns:
    A new, empty ArrayList.
    See Also:
    arrList(int), arrList(java.util.Collection)
  - arrList
```
public static <E> List<E> arrList(int capacity)
```
    Creates an empty ArrayList with a given capacity.
    
    Parameters:
    capacity - The initial size of the returned ArrayList.
    
    Returns:
    A new, empty ArrayList that has an initial capacity of capacity elements.
    See Also:
    ArrayList.ArrayList(int)
  - arrList
```
public static <E> List<E> arrList(Collection<? extends E> c)
```
    Copies an existing Collection into a new ArrayList.
    
    Parameters:
    c - Collection whose elements are to be placed into the returned ArrayList.
    
    Returns:
    An ArrayList containing the elements of c.
    See Also:
    ArrayList.ArrayList(Collection)
  - recollect
```
public static <E> Collection<E> recollect(Class<? extends Collection> cl,
                          Collection<E> old)
```
    Copies an existing Collection into a new (non-abstract!) Collection class.
    
    Parameters:
    cl - Non-abstract Collection class.
    old - An existing Collection.
    
    Returns:
    A new instance of cl that contains all of the elements from old.
    
    Throws:
    
    RuntimeException - if there was trouble creating a new instance of cl.
    See Also:
    collect(Class, Object...)
  - zipMap
```
public static <K,V> Map<K,V> zipMap(K[] keys,
                    V[] values)
```
    Takes arrays of keys and values and merges them together to form a Map. The returned Map is a LinkedHashMap and is truncated in length to the length of the shorter parameter.
    This is intended for use as "varargs" supplied to arr(Object...). Rather than doing something ugly like:
```
 Map<String, String> mappy = new LinkedHashMap<String, String>();
 mappy.put("key0", "val0");
 mappy.put("key1", "val1");
 ...
 mappy.put("keyN", "valN");
 
```
    Simply do like so:
```
 mappy = zipMap(
     arr("key0", "key1", ..., "keyN"),
     arr("val0", "val1", ..., "valN"));
 
```
    The latter approach also allows you to make static final Maps much more easily.
    Parameters:
    keys - Array whose elements will be the keys in a Map.
    values - Array whose elements will the values in a Map.
    
    Returns:
    A Map whose entries are of the form keys[N], values[N].
    See Also:
    arr(Object...), zipMap(java.util.Collection, java.util.Collection)
  - zipMap
```
public static <K,V> Map<K,V> zipMap(Collection<? extends K> keys,
                    Collection<? extends V> values)
```
    A version of zipMap(Object[], Object[]) that works with Collections.
    
    Parameters:
    keys - Items that will be the keys in the resulting Map.
    values - Items that will be the values in the result Map.
    
    Returns:
    A Map whose entries are of the form keys[N], values[N].
    See Also:
    zipMap(Object[], Object[])
  - map
```
public static <A,B> List<B> map(Function<A,B> f,
                List<A> as)
```
    Applies a given function to each item in a given list.
    
    Parameters:
    f - The Function to apply.
    as - The list whose items are to be fed into f.
    
    Returns:
    New list containing the results of each element of as being passed through f.
  - map
```
public static <A,B> Set<B> map(Function<A,B> f,
               Set<A> as)
```
    Applies a given function to each item in a given Set.
    
    Parameters:
    f - The Function to apply to as.
    as - The Set whose items are to be fed into f.
    
    Returns:
    New Set containing the results of passing each element in as through f.

Class CollectionHelpers

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CollectionHelpers

Method Detail

arr

list

set

collect

len

contains

newHashSet

newHashSet

newHashSet

newLinkedHashSet

newLinkedHashSet

newLinkedHashSet

newMap

newMap

newMap

newLinkedHashMap

newLinkedHashMap

newLinkedHashMap

concurrentMap

concurrentList

concurrentList

concurrentList

concurrentSet

concurrentSet

concurrentSet

linkedList

linkedList

arrList

arrList

arrList

recollect

zipMap

zipMap

map

map