Maps (common 0.0.4 API)

java.lang.Object
- de.javagl.common.collections.Maps

```
public class Maps
extends Object
```
Utility methods related to maps

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <K,E> void`	`addToList(Map<K,List<E>> map, K k, E e)` Adds the given element to the list that is stored under the given key.
`static <K,V> Map<K,List<V>>`	`combine(Collection<? extends Map<? extends K,? extends V>> maps)` Combine the given maps, by merging their key sets to obtain the key set of the result list, and collecting all values from the given input maps into lists.
`static <T> Map<T,Integer>`	`createIndexLookup(List<? extends T> list)` Create a map for looking up the indices of the elements in the given list.
`static <T> Map<T,Integer>`	`createIndexLookupUnchecked(List<? extends T> list)` Create a map that is an index lookup for the given list.
`static <K,V> void`	`fillValues(Map<K,V> map, Iterable<? extends V> values)` Fill the given map sequentially with the values from the given sequence.
`static <T> Map<Integer,T>`	`fromElements(T... elements)` Creates a map that maps consecutive integer values to the corresponding elements in the given array.
`static <K,V> Map<K,V>`	`fromEntries(Iterable<? extends Map.Entry<? extends K,? extends V>> entries)` Creates a new map from the given sequence of entries
`static <T> Map<Integer,T>`	`fromIterable(Iterable<? extends T> iterable)` Creates a map that maps consecutive integer values to the elements in the given sequence, in the order in which they appear.
`static <K,V> Map<K,V>`	`fromIterables(Iterable<? extends K> iterable0, Iterable<? extends V> iterable1)` Creates a map that maps the elements of the first sequence to the corresponding elements in the second sequence.
`static <K> Integer`	`getCount(Map<K,Integer> map, K k)` Returns the value that is stored for the given key in the given map.
`static <K> void`	`incrementCount(Map<K,Integer> map, K k)` Increments the value that is stored for the given key in the given map by one, or sets it to 1 if there was no value stored for the given key.
`static <K,V extends Number> Map<K,V>`	`sortByNumberValue(Map<K,V> map, boolean ascending)` Sorts the given map by the double value of the values
`static <KI,VI,KO,VO> Map<KO,VO>`	`transform(Map<KI,VI> map, Function<? super KI,? extends KO> keyTransform, Function<? super VI,? extends VO> valueTransform)` Transform the keys and values of the given map with the given functions, and return the result as a new map.
`static <K,V> Map<K,V>`	`unmodifiableCopy(Map<? extends K,? extends V> map)` Creates an unmodifiable copy of the given map

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

- Method Detail
  - createIndexLookupUnchecked
```
public static <T> Map<T,Integer> createIndexLookupUnchecked(List<? extends T> list)
```
    Create a map that is an index lookup for the given list. If the list contains duplicate elements, then the element will be mapped to the last index at which it appears.
    
    Type Parameters:
    
    T - The element type
    
    Parameters:
    
    list - The list
    
    Returns:
    
    The map
  - createIndexLookup
```
public static <T> Map<T,Integer> createIndexLookup(List<? extends T> list)
```
    Create a map for looking up the indices of the elements in the given list.
    
    Type Parameters:
    
    T - The element type
    
    Parameters:
    
    list - The list
    
    Returns:
    
    The lookup
    
    Throws:
    
    IllegalArgumentException - If the list contains duplicate elements
  - combine
```
public static <K,V> Map<K,List<V>> combine(Collection<? extends Map<? extends K,? extends V>> maps)
```
    Combine the given maps, by merging their key sets to obtain the key set of the result list, and collecting all values from the given input maps into lists.
    
    Type Parameters:
    
    K - The key type
    
    V - The value type
    
    Parameters:
    
    maps - The input maps
    
    Returns:
    
    The resulting map
  - sortByNumberValue
```
public static <K,V extends Number> Map<K,V> sortByNumberValue(Map<K,V> map,
                                                              boolean ascending)
```
    Sorts the given map by the double value of the values
    
    Type Parameters:
    
    K - The key type
    
    V - The value type
    
    Parameters:
    
    map - The input map
    
    ascending - Whether the map should be sorted ascendingly
    
    Returns:
    
    The sorted map
  - fromEntries
```
public static <K,V> Map<K,V> fromEntries(Iterable<? extends Map.Entry<? extends K,? extends V>> entries)
```
    Creates a new map from the given sequence of entries
    
    Type Parameters:
    
    K - The key type
    
    V - The value type
    
    Parameters:
    
    entries - The entries
    
    Returns:
    
    The map
  - transform
```
public static <KI,VI,KO,VO> Map<KO,VO> transform(Map<KI,VI> map,
                                                 Function<? super KI,? extends KO> keyTransform,
                                                 Function<? super VI,? extends VO> valueTransform)
```
    Transform the keys and values of the given map with the given functions, and return the result as a new map. If the given key transform functions maps multiple input keys to the same output key, then the output key will be mapped to the last output value that was computed.
    
    Type Parameters:
    
    KI - The input key type
    
    VI - The input value type
    
    KO - The output key type
    
    VO - The output value type
    
    Parameters:
    
    map - The input map
    
    keyTransform - The key transform
    
    valueTransform - The value transform
    
    Returns:
    
    The resulting map
  - incrementCount
```
public static <K> void incrementCount(Map<K,Integer> map,
                                      K k)
```
    Increments the value that is stored for the given key in the given map by one, or sets it to 1 if there was no value stored for the given key.
    
    Type Parameters:
    
    K - The key type
    
    Parameters:
    
    map - The map
    
    k - The key
  - getCount
```
public static <K> Integer getCount(Map<K,Integer> map,
                                   K k)
```
    Returns the value that is stored for the given key in the given map. If there is no value stored, then 0 will be inserted into the map and returned
    
    Type Parameters:
    
    K - The key type
    
    Parameters:
    
    map - The map
    
    k - The key
    
    Returns:
    
    The value
  - addToList
```
public static <K,E> void addToList(Map<K,List<E>> map,
                                   K k,
                                   E e)
```
    Adds the given element to the list that is stored under the given key. If the list does not yet exist, it is created and inserted into the map.
    
    Type Parameters:
    
    K - The key type
    
    E - The element type
    
    Parameters:
    
    map - The map
    
    k - The key
    
    e - The element
  - fillValues
```
public static <K,V> void fillValues(Map<K,V> map,
                                    Iterable<? extends V> values)
```
    Fill the given map sequentially with the values from the given sequence. This method will iterate over all keys of the given map, and put the corresponding value element into the map. If the map is larger than the sequence, then the remaining entries will remain unaffected.
    
    Type Parameters:
    
    K - The key type
    
    V - The value type
    
    Parameters:
    
    map - The map to fill
    
    values - The values
  - fromElements
```
@SafeVarargs
public static <T> Map<Integer,T> fromElements(T... elements)
```
    Creates a map that maps consecutive integer values to the corresponding elements in the given array.
    
    Type Parameters:
    
    T - The value type
    
    Parameters:
    
    elements - The elements
    
    Returns:
    
    The map
  - fromIterable
```
public static <T> Map<Integer,T> fromIterable(Iterable<? extends T> iterable)
```
    Creates a map that maps consecutive integer values to the elements in the given sequence, in the order in which they appear.
    
    Type Parameters:
    
    T - The value type
    
    Parameters:
    
    iterable - The sequence
    
    Returns:
    
    The map
  - fromIterables
```
public static <K,V> Map<K,V> fromIterables(Iterable<? extends K> iterable0,
                                           Iterable<? extends V> iterable1)
```
    Creates a map that maps the elements of the first sequence to the corresponding elements in the second sequence. If the given sequences have different lengths, then only the elements of the shorter sequence will be contained in the map.
    
    Type Parameters:
    
    K - The key type
    
    V - The value type
    
    Parameters:
    
    iterable0 - The first sequence
    
    iterable1 - The second sequence
    
    Returns:
    
    The map
  - unmodifiableCopy
```
public static <K,V> Map<K,V> unmodifiableCopy(Map<? extends K,? extends V> map)
```
    Creates an unmodifiable copy of the given map
    
    Type Parameters:
    
    K - The key type
    
    V - The value type
    
    Parameters:
    
    map - The input map
    
    Returns:
    
    The resulting map

Class Maps

Method Summary

Methods inherited from class java.lang.Object

Method Detail

createIndexLookupUnchecked

createIndexLookup

combine

sortByNumberValue

fromEntries

transform

incrementCount

getCount

addToList

fillValues

fromElements

fromIterable

fromIterables

unmodifiableCopy