Maps (dishevelled.org collect 1.1-SNAPSHOT API)

java.lang.Object
- org.dishevelled.collect.Maps

```
public final class Maps
extends Object
```
Static utility methods for Maps.

Version:

$Revision$ $Date$

Author:

Michael Heuer

Method Summary

Methods
Modifier and Type	Method and Description
`static <K,V> ConcurrentMap<K,V>`	`createConcurrentMap()` Create and return a new instance of ConcurrentMap.
`static <K,V> ConcurrentMap<K,V>`	`createConcurrentMap(int initialCapacity)` Create and return a new instance of ConcurrentMap with the specified initial capacity.
`static <K,V> ConcurrentMap<K,V>`	`createConcurrentMap(int initialCapacity, float loadFactor)` Create and return a new instance of ConcurrentMap with the specified initial capacity and load factor.
`static <K,V> ConcurrentMap<K,V>`	`createConcurrentMap(int initialCapacity, float loadFactor, int concurrencyLevel)` Create and return a new instance of ConcurrentMap with the specified initial capacity, load factor, and concurrency level.
`static <K,V> ConcurrentMap<K,V>`	`createConcurrentMap(Map<? extends K,? extends V> map)` Create and return a new instance of ConcurrentMap with the same mappings as the specified map.
`static <K,V> ConcurrentSkipListMap<K,V>`	`createConcurrentSkipListMap()` Create and return a new instance of ConcurrentSkipListMap sorted according to the natural ordering of its keys.
`static <K,V> ConcurrentSkipListMap<K,V>`	`createConcurrentSkipListMap(Comparator<? super K> comparator)` Create and return a new instance of ConcurrentSkipListMap sorted according to the specified comparator.
`static <K,V> ConcurrentSkipListMap<K,V>`	`createConcurrentSkipListMap(Map<? extends K,? extends V> map)` Create and return a new instance of ConcurrentSkipListMap containing the same mappings as the specified map and sorted according to the natural ordering of its keys.
`static <K,V> ConcurrentSkipListMap<K,V>`	`createConcurrentSkipListMap(SortedMap<K,? extends V> sortedMap)` Create and return a new instance of ConcurrentSkipListMap containing the same mappings and using the same ordering as the specified sorted map.
`static <V> ConcurrentMap<Long,V>`	`createLongNonBlockingMap()` Create and return a new non-blocking implementation of ConcurrentMap with `Long`s as keys.
`static <V> ConcurrentMap<Long,V>`	`createLongNonBlockingMap(boolean optimizeForSpace)` Create and return a new non-blocking implementation of ConcurrentMap with `Long`s as keys.
`static <V> ConcurrentMap<Long,V>`	`createLongNonBlockingMap(int initialCapacity)` Create and return a new non-blocking implementation of ConcurrentMap with the specified initial capacity and `Long`s as keys.
`static <V> ConcurrentMap<Long,V>`	`createLongNonBlockingMap(int initialCapacity, boolean optimizeForSpace)` Create and return a new non-blocking implementation of ConcurrentMap with the specified initial capacity and `Long`s as keys.
`static <K,V> Map<K,V>`	`createMap()` Create and return a new instance of Map.
`static <K,V> Map<K,V>`	`createMap(int initialCapacity)` Create and return a new instance of Map with the specified initial capacity.
`static <K,V> Map<K,V>`	`createMap(int initialCapacity, float loadFactor)` Create and return a new instance of Map with the specified initial capacity and load factor.
`static <K,V> Map<K,V>`	`createMap(Map<? extends K,? extends V> map)` Create and return a new instance of Map with the same mappings as the specified map.
`static <K,V> NavigableMap<K,V>`	`createNavigableMap()` Create and return a new instance of NavigableMap using the natural ordering of its keys.
`static <K,V> NavigableMap<K,V>`	`createNavigableMap(Comparator<? super K> comparator)` Create and return a new instance of NavigableMap ordered according to the specified comparator.
`static <K,V> NavigableMap<K,V>`	`createNavigableMap(Map<? extends K,? extends V> map)` Create and return a new instance of NavigableMap containing the same mappings as the specified map ordered according to the natural ordering of its keys.
`static <K,V> NavigableMap<K,V>`	`createNavigableMap(NavigableMap<K,? extends V> navigableMap)` Create and return a new instance of NavigableMap containing the same mappings and the same ordering as the specified navigable map.
`static <K,V> ConcurrentMap<K,V>`	`createNonBlockingMap()` Create and return a new non-blocking implementation of ConcurrentMap.
`static <K,V> ConcurrentMap<K,V>`	`createNonBlockingMap(int initialCapacity)` Create and return a new non-blocking implementation of ConcurrentMap with the specified initial capacity.
`static <K,V> SortedMap<K,V>`	`createSortedMap()` Create and return a new instance of SortedMap using the natural ordering of its keys.
`static <K,V> SortedMap<K,V>`	`createSortedMap(Comparator<? super K> comparator)` Create and return a new instance of SortedMap ordered according to the specified comparator.
`static <K,V> SortedMap<K,V>`	`createSortedMap(Map<? extends K,? extends V> map)` Create and return a new instance of SortedMap containing the same mappings as the specified map ordered according to the natural ordering of its keys.
`static <K,V> SortedMap<K,V>`	`createSortedMap(SortedMap<K,? extends V> sortedMap)` Create and return a new instance of SortedMap containing the same mappings and the same ordering as the specified sorted map.
`static <K,V> Map<K,V>`	`createSynchronizedMap()` Create and return a new synchronized (thread-safe) instance of Map.
`static <K,V> Map<K,V>`	`createSynchronizedMap(int initialCapacity)` Create and return a new synchronized (thread-safe) instance of Map with the specified initial capacity.
`static <K,V> Map<K,V>`	`createSynchronizedMap(int initialCapacity, float loadFactor)` Create and return a new synchronized (thread-safe) instance of Map with the specified initial capacity and load factor.
`static <K,V> Map<K,V>`	`createSynchronizedMap(Map<? extends K,? extends V> map)` Create and return a new synchronized (thread-safe) instance of Map with the same mappings as the specified map.
`static <K,V> Map<K,V>`	`emptyMap()` Create and return a new empty map.
`static <K,V> Map<K,V>`	`immutableMap(Map<? extends K,? extends V> map)` Create and return an immutable map containing the same mappings as the specified map.
`static <K,V> SortedMap<K,V>`	`immutableSortedMap(SortedMap<K,? extends V> sortedMap)` Create and return an immutable sorted map containing the same mappings and the same ordering as the specified sorted map.
`static <K,V> Map<K,V>`	`unmodifiableMap(Map<? extends K,? extends V> map)` Create and return a new unmodifiable view of the specified map.
`static <K,V> SortedMap<K,V>`	`unmodifiableSortedMap(SortedMap<K,? extends V> sortedMap)` Create and return a new unmodifiable view of the specified sorted map.

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

- Method Detail
  - emptyMap
```
public static <K,V> Map<K,V> emptyMap()
```
    Create and return a new empty map. Delegates to Collections.emptyMap().
    
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new empty map
  - createMap
```
public static <K,V> Map<K,V> createMap()
```
    Create and return a new instance of Map.
    
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new instance of Map
  - createMap
```
public static <K,V> Map<K,V> createMap(int initialCapacity)
```
    Create and return a new instance of Map with the specified initial capacity.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    
    Returns:
    a new instance of Map with the specified initial capacity
  - createMap
```
public static <K,V> Map<K,V> createMap(int initialCapacity,
                       float loadFactor)
```
    Create and return a new instance of Map with the specified initial capacity and load factor.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    loadFactor - load factor
    
    Returns:
    a new instance of Map with the specified initial capacity and load factor
  - createMap
```
public static <K,V> Map<K,V> createMap(Map<? extends K,? extends V> map)
```
    Create and return a new instance of Map with the same mappings as the specified map. The map is created with default load factor (0.75) and an initial capacity sufficient to hold the mappings in the specified map.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to copy mappings from
    
    Returns:
    a new instance of Map with the same mappings as the specified map
  - createSynchronizedMap
```
public static <K,V> Map<K,V> createSynchronizedMap()
```
    Create and return a new synchronized (thread-safe) instance of Map. It is imperative that the user manually synchronize on the returned map when iterating over any of its collection views:
```
 Map m = Maps.newSynchronizedMap();
 ...
 Set s = m.keySet();  // Needn't be in synchronized block
 ...
 synchronized(m)  // Synchronizing on m, not s!
 {
   Iterator i = s.iterator(); // Must be in synchronized block
   while (i.hasNext())
   {
      foo(i.next());
   }
 }
 
```
    Failure to follow this advice may result in non-deterministic behavior.
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new synchronized (thread-safe) instance of Map
  - createSynchronizedMap
```
public static <K,V> Map<K,V> createSynchronizedMap(int initialCapacity)
```
    Create and return a new synchronized (thread-safe) instance of Map with the specified initial capacity. It is imperative that the user manually synchronize on the returned map when iterating over any of its collection views:
```
 Map m = Maps.newSynchronizedMap(10);
 ...
 Set s = m.keySet();  // Needn't be in synchronized block
 ...
 synchronized(m)  // Synchronizing on m, not s!
 {
   Iterator i = s.iterator(); // Must be in synchronized block
   while (i.hasNext())
   {
      foo(i.next());
   }
 }
 
```
    Failure to follow this advice may result in non-deterministic behavior.
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    
    Returns:
    a new synchronized (thread-safe) instance of Map with the specified initial capacity
  - createSynchronizedMap
```
public static <K,V> Map<K,V> createSynchronizedMap(int initialCapacity,
                                   float loadFactor)
```
    Create and return a new synchronized (thread-safe) instance of Map with the specified initial capacity and load factor. It is imperative that the user manually synchronize on the returned map when iterating over any of its collection views:
```
 Map m = Maps.newSynchronizedMap(10, 0.80);
 ...
 Set s = m.keySet();  // Needn't be in synchronized block
 ...
 synchronized(m)  // Synchronizing on m, not s!
 {
   Iterator i = s.iterator(); // Must be in synchronized block
   while (i.hasNext())
   {
      foo(i.next());
   }
 }
 
```
    Failure to follow this advice may result in non-deterministic behavior.
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    loadFactor - load factor
    
    Returns:
    a new synchronized (thread-safe) instance of Map with the specified intial capacity and load factor
  - createSynchronizedMap
```
public static <K,V> Map<K,V> createSynchronizedMap(Map<? extends K,? extends V> map)
```
    Create and return a new synchronized (thread-safe) instance of Map with the same mappings as the specified map. The map is created with default load factor (0.75) and an initial capacity sufficient to hold the mappings in the specified map. It is imperative that the user manually synchronize on the returned map when iterating over any of its collection views:
```
 Map m = Maps.newSynchronizedMap(map);
 ...
 Set s = m.keySet();  // Needn't be in synchronized block
 ...
 synchronized(m)  // Synchronizing on m, not s!
 {
   Iterator i = s.iterator(); // Must be in synchronized block
   while (i.hasNext())
   {
      foo(i.next());
   }
 }
 
```
    Failure to follow this advice may result in non-deterministic behavior.
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to copy mappings from
    
    Returns:
    a new synchronized (thread-safe) instance of Map with the same mappings as the specified map
  - createConcurrentMap
```
public static <K,V> ConcurrentMap<K,V> createConcurrentMap()
```
    Create and return a new instance of ConcurrentMap.
    
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new instance of ConcurrentMap
  - createConcurrentMap
```
public static <K,V> ConcurrentMap<K,V> createConcurrentMap(int initialCapacity)
```
    Create and return a new instance of ConcurrentMap with the specified initial capacity.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    
    Returns:
    a new instance of ConcurrentMap with the specified initial capacity
  - createConcurrentMap
```
public static <K,V> ConcurrentMap<K,V> createConcurrentMap(int initialCapacity,
                                           float loadFactor)
```
    Create and return a new instance of ConcurrentMap with the specified initial capacity and load factor.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    loadFactor - load factor
    
    Returns:
    a new instance of ConcurrentMap with the specified initial capacity and load factor
  - createConcurrentMap
```
public static <K,V> ConcurrentMap<K,V> createConcurrentMap(int initialCapacity,
                                           float loadFactor,
                                           int concurrencyLevel)
```
    Create and return a new instance of ConcurrentMap with the specified initial capacity, load factor, and concurrency level.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    loadFactor - load factor
    concurrencyLevel - concurrency level
    
    Returns:
    a new instance of ConcurrentMap with the specified initial capacity load factor, and concurrency level
  - createConcurrentMap
```
public static <K,V> ConcurrentMap<K,V> createConcurrentMap(Map<? extends K,? extends V> map)
```
    Create and return a new instance of ConcurrentMap with the same mappings as the specified map. The concurrent map is created with default load factor (0.75) and an initial capacity sufficient to hold the mappings in the specified map.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to copy mappings from, must not be null
    
    Returns:
    a new instance of ConcurrentMap with the same mappings as the specified map
  - createNonBlockingMap
```
public static <K,V> ConcurrentMap<K,V> createNonBlockingMap()
```
    Create and return a new non-blocking implementation of ConcurrentMap.
    
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new non-blocking implementation of ConcurrentMap
  - createNonBlockingMap
```
public static <K,V> ConcurrentMap<K,V> createNonBlockingMap(int initialCapacity)
```
    Create and return a new non-blocking implementation of ConcurrentMap with the specified initial capacity.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    initialCapacity - initial capacity
    
    Returns:
    a new non-blocking implementation of ConcurrentMap with the specified initial capacity
  - createLongNonBlockingMap
```
public static <V> ConcurrentMap<Long,V> createLongNonBlockingMap()
```
    Create and return a new non-blocking implementation of ConcurrentMap with Longs as keys.
    
    Type Parameters:
    V - value type
    
    Returns:
    a new non-blocking implementation of ConcurrentMap with Longs as keys
  - createLongNonBlockingMap
```
public static <V> ConcurrentMap<Long,V> createLongNonBlockingMap(boolean optimizeForSpace)
```
    Create and return a new non-blocking implementation of ConcurrentMap with Longs as keys.
    
    Type Parameters:
    V - value type
    Parameters:
    optimizeForSpace - true if the implementation should optimize for space
    
    Returns:
    a new non-blocking implementation of ConcurrentMap with Longs as keys
  - createLongNonBlockingMap
```
public static <V> ConcurrentMap<Long,V> createLongNonBlockingMap(int initialCapacity)
```
    Create and return a new non-blocking implementation of ConcurrentMap with the specified initial capacity and Longs as keys.
    
    Type Parameters:
    V - value type
    Parameters:
    initialCapacity - initial capacity
    
    Returns:
    a new non-blocking implementation of ConcurrentMap with the specified initial capacity and Longs as keys
  - createLongNonBlockingMap
```
public static <V> ConcurrentMap<Long,V> createLongNonBlockingMap(int initialCapacity,
                                                 boolean optimizeForSpace)
```
    Create and return a new non-blocking implementation of ConcurrentMap with the specified initial capacity and Longs as keys.
    
    Type Parameters:
    V - value type
    Parameters:
    initialCapacity - initial capacity
    optimizeForSpace - true if this implementation should optimize for space
    
    Returns:
    a new non-blocking implementation of ConcurrentMap with the specified initial capacity and Longs as keys
  - createConcurrentSkipListMap
```
public static <K,V> ConcurrentSkipListMap<K,V> createConcurrentSkipListMap()
```
    Create and return a new instance of ConcurrentSkipListMap sorted according to the natural ordering of its keys.
    
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new instance of ConcurrentSkipListMap sorted according to the natural ordering of its keys
  - createConcurrentSkipListMap
```
public static <K,V> ConcurrentSkipListMap<K,V> createConcurrentSkipListMap(Comparator<? super K> comparator)
```
    Create and return a new instance of ConcurrentSkipListMap sorted according to the specified comparator.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    comparator - comparator that will be used to order this map, or null to use the natural ordering of its keys
    
    Returns:
    a new instance of ConcurrentSkipListMap sorted according to the specified comparator
  - createConcurrentSkipListMap
```
public static <K,V> ConcurrentSkipListMap<K,V> createConcurrentSkipListMap(Map<? extends K,? extends V> map)
```
    Create and return a new instance of ConcurrentSkipListMap containing the same mappings as the specified map and sorted according to the natural ordering of its keys.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to copy mappings from, must not be null
    
    Returns:
    a new instance of ConcurrentSkipListMap containing the same mappings as the specified map and sorted according to the natural ordering of its keys
  - createConcurrentSkipListMap
```
public static <K,V> ConcurrentSkipListMap<K,V> createConcurrentSkipListMap(SortedMap<K,? extends V> sortedMap)
```
    Create and return a new instance of ConcurrentSkipListMap containing the same mappings and using the same ordering as the specified sorted map.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    sortedMap - sorted map to copy mappings and ordering from, must not be null
    
    Returns:
    a new instance of ConcurrentSkipListMap containing the same mappings and using the same ordering as the specified sorted map
  - createSortedMap
```
public static <K,V> SortedMap<K,V> createSortedMap()
```
    Create and return a new instance of SortedMap using the natural ordering of its keys.
    
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new instance of SortedMap using the natural ordering of its keys
  - createSortedMap
```
public static <K,V> SortedMap<K,V> createSortedMap(Comparator<? super K> comparator)
```
    Create and return a new instance of SortedMap ordered according to the specified comparator.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    comparator - comparator used to order this map, or null to use the natural ordering of its keys
    
    Returns:
    a new instance of SortedMap ordered according to the specified comparator
  - createSortedMap
```
public static <K,V> SortedMap<K,V> createSortedMap(Map<? extends K,? extends V> map)
```
    Create and return a new instance of SortedMap containing the same mappings as the specified map ordered according to the natural ordering of its keys.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to copy mappings from, must not be null
    
    Returns:
    a new instance of SortedMap containing the same mappings as the specified map ordered according to the natural ordering of its keys
  - createSortedMap
```
public static <K,V> SortedMap<K,V> createSortedMap(SortedMap<K,? extends V> sortedMap)
```
    Create and return a new instance of SortedMap containing the same mappings and the same ordering as the specified sorted map.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    sortedMap - sorted map to copy mappings and comparator from, must not be null
    
    Returns:
    a new instance of SortedMap containing the same mappings and the same ordering as the specified sorted map
  - createNavigableMap
```
public static <K,V> NavigableMap<K,V> createNavigableMap()
```
    Create and return a new instance of NavigableMap using the natural ordering of its keys.
    
    Type Parameters:
    K - key type
    V - value type
    
    Returns:
    a new instance of NavigableMap using the natural ordering of its keys
  - createNavigableMap
```
public static <K,V> NavigableMap<K,V> createNavigableMap(Comparator<? super K> comparator)
```
    Create and return a new instance of NavigableMap ordered according to the specified comparator.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    comparator - comparator used to order this map, or null to use the natural ordering of its keys
    
    Returns:
    a new instance of NavigableMap ordered according to the specified comparator
  - createNavigableMap
```
public static <K,V> NavigableMap<K,V> createNavigableMap(Map<? extends K,? extends V> map)
```
    Create and return a new instance of NavigableMap containing the same mappings as the specified map ordered according to the natural ordering of its keys.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to copy mappings from, must not be null
    
    Returns:
    a new instance of NavigableMap containing the same mappings as the specified map ordered according to the natural ordering of its keys
  - createNavigableMap
```
public static <K,V> NavigableMap<K,V> createNavigableMap(NavigableMap<K,? extends V> navigableMap)
```
    Create and return a new instance of NavigableMap containing the same mappings and the same ordering as the specified navigable map.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    navigableMap - navigable map to copy mappings and comparator from, must not be null
    
    Returns:
    a new instance of NavigableMap containing the same mappings and the same ordering as the specified navigable map
  - unmodifiableMap
```
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> map)
```
    Create and return a new unmodifiable view of the specified map. Query operations on the returned map "read through" to the specified map. Attempts to modify the returned map, whether direct or via its collection views, result in an UnsupportedOperationException.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to view, must not be null
    
    Returns:
    a new unmodifiable view of the specified map
  - unmodifiableSortedMap
```
public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> sortedMap)
```
    Create and return a new unmodifiable view of the specified sorted map. Query operations on the returned sorted map "read through" to the specified sorted map. Attempts to modify the returned sorted map, whether direct, via its collection views, or via its subMap, headMap, or tailMap views, result in an UnsupportedOperationException.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    sortedMap - sorted map to view, must not be null
    
    Returns:
    a new unmodifiable view of the specified sorted map
  - immutableMap
```
public static <K,V> Map<K,V> immutableMap(Map<? extends K,? extends V> map)
```
    Create and return an immutable map containing the same mappings as the specified map.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    map - map to copy, must not be null
    
    Returns:
    an immutable map containing the same mappings as the specified map
  - immutableSortedMap
```
public static <K,V> SortedMap<K,V> immutableSortedMap(SortedMap<K,? extends V> sortedMap)
```
    Create and return an immutable sorted map containing the same mappings and the same ordering as the specified sorted map.
    
    Type Parameters:
    K - key type
    V - value type
    Parameters:
    sortedMap - sorted map to copy, must not be null
    
    Returns:
    an immutable sorted map containing the same mappings and the same ordering as the specified sorted map

Class Maps

Method Summary

Methods inherited from class java.lang.Object

Method Detail

emptyMap

createMap

createMap

createMap

createMap

createSynchronizedMap

createSynchronizedMap

createSynchronizedMap

createSynchronizedMap

createConcurrentMap

createConcurrentMap

createConcurrentMap

createConcurrentMap

createConcurrentMap

createNonBlockingMap

createNonBlockingMap

createLongNonBlockingMap

createLongNonBlockingMap

createLongNonBlockingMap

createLongNonBlockingMap

createConcurrentSkipListMap

createConcurrentSkipListMap

createConcurrentSkipListMap

createConcurrentSkipListMap

createSortedMap

createSortedMap

createSortedMap

createSortedMap

createNavigableMap

createNavigableMap

createNavigableMap

createNavigableMap

unmodifiableMap

unmodifiableSortedMap

immutableMap

immutableSortedMap