org.codehaus.plexus.util

Class CollectionUtils

java.lang.Object

org.codehaus.plexus.util.CollectionUtils

public class CollectionUtils
extends Object

Author:

olamy

Constructor Summary

Constructors

Constructor and Description
CollectionUtils()

Method Summary

Modifier and Type	Method and Description
static <E> Map<E,Integer>	getCardinalityMap(Collection<E> col) Returns a Map mapping each unique element in the given Collection to an Integer representing the number of occurrences of that element in the Collection.
static <E> Collection<E>	intersection(Collection<E> a, Collection<E> b) Returns a Collection containing the intersection of the given Collections.
static <E> List<E>	iteratorToList(Iterator<E> it)
static <K,V> Map<K,V>	mergeMaps(Map<K,V>[] maps) Take a series of Maps and merge them where the ordering of the array from 0..n is the dominant order.
static <K,V> Map<K,V>	mergeMaps(Map<K,V> dominantMap, Map<K,V> recessiveMap) Take a dominant and recessive Map and merge the key:value pairs where the recessive Map may add key:value pairs to the dominant Map but may not override any existing key:value pairs.
static <T> Collection<T>	subtract(Collection<T> a, Collection<T> b) Returns a Collection containing a - b.

Methods inherited from class java.lang.Object

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

Constructor Detail

CollectionUtils

public CollectionUtils()

Method Detail

mergeMaps

public static <K,V> Map<K,V> mergeMaps(Map<K,V> dominantMap,
                                       Map<K,V> recessiveMap)

Take a dominant and recessive Map and merge the key:value pairs where the recessive Map may add key:value pairs to the dominant Map but may not override any existing key:value pairs. If we have two Maps, a dominant and recessive, and their respective keys are as follows: dominantMapKeys = { a, b, c, d, e, f } recessiveMapKeys = { a, b, c, x, y, z } Then the result should be the following: resultantKeys = { a, b, c, d, e, f, x, y, z }

Type Parameters:

K - type

V - type

Parameters:

dominantMap - Dominant Map.

recessiveMap - Recessive Map.

Returns:

The result map with combined dominant and recessive values.

mergeMaps

public static <K,V> Map<K,V> mergeMaps(Map<K,V>[] maps)

Take a series of Maps and merge them where the ordering of the array from 0..n is the dominant order.

Type Parameters:

K - type

V - type

Parameters:

maps - An array of Maps to merge.

Returns:

Map The result Map produced after the merging process.

intersection

public static <E> Collection<E> intersection(Collection<E> a,
                                             Collection<E> b)

Returns a Collection containing the intersection of the given Collections.

The cardinality of each element in the returned Collection will be equal to the minimum of the cardinality of that element in the two given Collections.

Type Parameters:

E - the type

Parameters:

a - The first collection

b - The second collection

Returns:

The intersection of a and b, never null

See Also:

Collection.retainAll(java.util.Collection<?>)

subtract

public static <T> Collection<T> subtract(Collection<T> a,
                                         Collection<T> b)

Returns a Collection containing a - b. The cardinality of each element e in the returned Collection will be the cardinality of e in a minus the cardinality of e in b, or zero, whichever is greater.

Type Parameters:

T - the type

Parameters:

a - The start collection

b - The collection that will be subtracted

Returns:

The result of the subtraction

See Also:

Collection.removeAll(java.util.Collection<?>)

getCardinalityMap

public static <E> Map<E,Integer> getCardinalityMap(Collection<E> col)

Returns a Map mapping each unique element in the given Collection to an Integer representing the number of occurrences of that element in the Collection. An entry that maps to null indicates that the element does not appear in the given Collection.

Type Parameters:

E - the type

Parameters:

col - The collection to count cardinalities for

Returns:

A map of counts, indexed on each element in the collection

iteratorToList

public static <E> List<E> iteratorToList(Iterator<E> it)