MapUtil (commons-util 1.2.17 API)

java.lang.Object
- de.unkrig.commons.util.collections.MapUtil

public final class MapUtil
extends Object

Various utility methods for map processing.

Field Summary

Fields
Modifier and Type Field and Description

static SortedMap EMPTY_SORTED_MAP
Desperately missing from java.util.Collections.

Fields
Modifier and Type	Field and Description
`static SortedMap`	`EMPTY_SORTED_MAP` Desperately missing from `java.util.Collections`.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <K,V> Map<K,V>`	`augment(Map<K,V> delegate, K extraKey, V extraValue)` Returns a `Map` that is composed of the `delegate` and one extra entry.
`static <K,V> Map<K,V>`	`combine(Map<K,V> map1, Map<K,V> map2)` Returns a `Map` that is composed of `map1` and `map2`, where `map1` takes precedence over <`map2`.
`static <K,V> SortedMap<K,V>`	`emptySortedMap()` Desperately missing from `java.util.Collections`.
`static <K,V> Map.Entry<K,V>`	`entry(K key, V initialValue)`
`static boolean`	`equal(Object o1, Object o2)` Deprecated. Moved to `ObjectUtil.equals(Object, Object)`
`static <K,V> Map<K,V>`	`fromMappings(Object... keysAndValues)` Deprecated. Use `map(Object...)` instead
`static <K,V> HashMap<K,V>`	`hashMapOf(int initialCapacity, Map.Entry<? extends K,? extends V>... entries)`
`static <K,V> HashMap<K,V>`	`hashMapOf(Map.Entry<? extends K,? extends V>... entries)` Creates, fills and returns a `HashMap`.
`static <K,V,I> Map<K,V>`	`lazyMap(Map<K,Function<? super I,? extends V>> valueGetters, I in)` Creates and returns map that computes values only on demand, e.g. when `Map.entrySet().iterator().next().getValue()` is invoked, by calling `valueGetters.get(key).call(in)`.
`static <K,V> Map<K,V>`	`lazyMap(Map<K,Producer<? extends V>> valueGetters)` Creates and returns a map that produces values through the `valueGetters` map only when they are needed.
`static <K,V> Map<K,V>`	`map(K[] keys, V[] values)` Returns an unmodifiable map, mapping the given key-value pairs.
`static <K,V> Map<K,V>`	`map(Object... keyValuePairs)` Returns an unmodifiable map, mapping the given key-value pairs.
`static <K,V> Map<K,V>`	`override(Map<K,V> delegate, K extraKey, V extraValue)` Returns a `Map` that is composed of the `delegate` and one extra entry.
`static <K,V,M extends Map<K,V>> M`	`putAll(M subject, boolean allowDuplicateKeys, Map.Entry<? extends K,? extends V>... entries)` Puts all `entries` into the `subject`.
`static <K,V,M extends Map<K,V>> M`	`putAll(M subject, Map.Entry<? extends K,? extends V>... entries)` Puts all `entries` into the `subject`.
`static <K,V1,V2> Map<K,V2>`	`transformingMap(Map<K,? extends V1> delegate, Function<V1,V2> transformer)` Wraps the `delegate` map such that values are fed through the `transformer` whenever they are needed.
`static <K,V> TreeMap<K,V>`	`treeMapOf(Map.Entry<? extends K,? extends V>... entries)`

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

- Field Detail
  - EMPTY_SORTED_MAP
```
public static final SortedMap EMPTY_SORTED_MAP
```
    Desperately missing from java.util.Collections.
- Method Detail
  - map
```
public static <K,V> Map<K,V> map(Object... keyValuePairs)
```
    Returns an unmodifiable map, mapping the given key-value pairs. null keys and null values are supported.
    
    Parameters:
    
    keyValuePairs - An alternating sequence of keys and values
    
    Throws:
    
    ArrayIndexOutOfBoundsException - The length of keyValuePairs is odd
    
    IllegalArgumentException - Two of the keys are equal
  - map
```
public static <K,V> Map<K,V> map(K[] keys,
                                 V[] values)
```
    Returns an unmodifiable map, mapping the given key-value pairs. null keys and null values are supported.
    
    Throws:
    
    ArrayIndexOutOfBoundsException - The length of keyValuePairs is odd
    
    IllegalArgumentException - Two of the keys are equal
  - hashMapOf
```
public static <K,V> HashMap<K,V> hashMapOf(Map.Entry<? extends K,? extends V>... entries)
```
    Creates, fills and returns a HashMap. The initial capacity of the HashMap is chosen to be optimal for the number of entries.
    
    Returns:
    
    A HashMap containing all entries
    
    Throws:
    
    IllegalArgumentException - Two entries have equal keys
  - hashMapOf
```
public static <K,V> HashMap<K,V> hashMapOf(int initialCapacity,
                                           Map.Entry<? extends K,? extends V>... entries)
```
    Parameters:
    
    initialCapacity - See the documentation of HashMap
    
    Returns:
    
    A HashMap containing all entries
    
    Throws:
    
    IllegalArgumentException - Two entries have equal keys
  - treeMapOf
```
public static <K,V> TreeMap<K,V> treeMapOf(Map.Entry<? extends K,? extends V>... entries)
```
    Returns:
    
    A TreeMap containing all entries
    
    Throws:
    
    IllegalArgumentException - Two entries have equal keys
  - putAll
```
public static <K,V,M extends Map<K,V>> M putAll(M subject,
                                                Map.Entry<? extends K,? extends V>... entries)
```
    Puts all entries into the subject.
    
    Returns:
    
    The subject
    
    Throws:
    
    IllegalArgumentException - Two entries have equal keys
  - putAll
```
public static <K,V,M extends Map<K,V>> M putAll(M subject,
                                                boolean allowDuplicateKeys,
                                                Map.Entry<? extends K,? extends V>... entries)
```
    Puts all entries into the subject.
    
    Returns:
    
    The subject
    
    Throws:
    
    IllegalArgumentException - Two entries have equal keys, and allowDuplicateKeys is false
  - entry
```
public static <K,V> Map.Entry<K,V> entry(K key,
                                         V initialValue)
```
    Returns:
    
    A Map.Entry with the given key and the initialValue
    
    See Also:
    
    Map.Entry.setValue(Object)
  - emptySortedMap
```
public static <K,V> SortedMap<K,V> emptySortedMap()
```
    Desperately missing from java.util.Collections.
  - combine
```
public static <K,V> Map<K,V> combine(Map<K,V> map1,
                                     Map<K,V> map2)
```
    Returns a Map that is composed of map1 and map2, where map1 takes precedence over <map2.
    All modifying operations are directed to map1; map2 is never modified.
  - augment
```
public static <K,V> Map<K,V> augment(Map<K,V> delegate,
                                     K extraKey,
                                     V extraValue)
```
    Returns a Map that is composed of the delegate and one extra entry. If the delegate contains the extraKey, then the value from the delegate takes precedence.
  - override
```
public static <K,V> Map<K,V> override(Map<K,V> delegate,
                                      K extraKey,
                                      V extraValue)
```
    Returns a Map that is composed of the delegate and one extra entry. If the delegate contains the extraKey, then the extraValue takes precedence.
  - equal
```
@Deprecated
public static boolean equal(@Nullable
                                         Object o1,
                                         @Nullable
                                         Object o2)
```
    Deprecated. Moved to ObjectUtil.equals(Object, Object)
  - fromMappings
```
@Deprecated
public static <K,V> Map<K,V> fromMappings(Object... keysAndValues)
```
    Deprecated. Use map(Object...) instead
  - lazyMap
```
public static <K,V,I> Map<K,V> lazyMap(Map<K,Function<? super I,? extends V>> valueGetters,
                                       @Nullable
                                       I in)
```
    Creates and returns map that computes values only on demand, e.g. when Map.entrySet().iterator().next().getValue() is invoked, by calling valueGetters.get(key).call(in). (in is the value of this method's in parameter, and can be used to convey "context information" to the valueGetters.)
    The returned map supports entry removal operations iff the valueGetters map supports them.
    
    The returned map does not support Map.put(Object, Object) and Map.putAll(Map) operations.
    
    The returned map is backed by the valueGetters map, i.e. modifications to either of the two maps is reflected by the other map.
    
    The returned map supports null keys iff the valueGetters map supports null keys.
    
    The returned map may return null values if there is no value getter for the key, or if the value getter returns null.
    
    Parameters:
    
    valueGetters - Must not contain null values
  - lazyMap
```
public static <K,V> Map<K,V> lazyMap(Map<K,Producer<? extends V>> valueGetters)
```
    Creates and returns a map that produces values through the valueGetters map only when they are needed.
  - transformingMap
```
public static <K,V1,V2> Map<K,V2> transformingMap(Map<K,? extends V1> delegate,
                                                  Function<V1,V2> transformer)
```
    Wraps the delegate map such that values are fed through the transformer whenever they are needed.

Class MapUtil

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EMPTY_SORTED_MAP

Method Detail

map

map

hashMapOf

hashMapOf

treeMapOf

putAll

putAll

entry

emptySortedMap

combine

augment

override

equal

fromMappings

lazyMap

lazyMap

transformingMap