org.codehaus.plexus.util

## Class CollectionUtils

- java.lang.Object
- - org.codehaus.plexus.util.CollectionUtils

-     public class CollectionUtils
      extends Object

  Version:
    $Id$
  Author:
    olamy

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `CollectionUtils()`

  - ### Method Summary

    Methods
    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 occurances 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 `Collection`s.
    `static <E> List<E>` | `iteratorToList(Iterator<E> it)`
    `static <K,V> Map<K,V>` | `mergeMaps(Map<K,V>[] maps)` Take a series of `Map`s 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 }
      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 `Map`s and merge them where the ordering of the array from 0..n is the dominant order.
      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 `Collection`s.

      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 `Collection`s.

      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.
      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 occurances of that element in the `Collection`. An entry that maps to `null` indicates that the element does not appear in the given `Collection`.
      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)

Copyright © 2015. All rights reserved.