java.lang.Object
- eu.simuline.util.ListMap<K,V>

Type Parameters:

K - the class of keys for this map.

V - the class of values for this map.

All Implemented Interfaces:

Map<K,V>, SortedMap<K,V>
```
public final class ListMap<K,V>
extends Object
implements SortedMap<K,V>
```
A SortedMap with ordering given by the ordering by which the keys are added. This is the Map corresponding with ListSet.
Did not use AbstractMap, e.g. because keySet() shall return more than just a Set.

Version:

1.0

Author:

Ernst Reissner

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private class`	`ListMap.Entries`	Represents the set of entries of the enclosing map given by `entrySet()`.
`private class`	`ListMap.EntriesIterator`	Class of iterator of class `ListMap.Entries`.
`private class`	`ListMap.Entry`	Class of entries of the encylosing map. **** I wonder whether there is no generic implementation for `Map.Entry`.
`private class`	`ListMap.Keys`	Represents the key set of the enclosing map given by `keySet()`.
`private class`	`ListMap.KeysIterator`	Class of iterator of class `ListMap.Keys`.
`private class`	`ListMap.Values`	Represents the values collection of the enclosing map given by `values()`.
`private class`	`ListMap.ValuesIterator`	Class of iterator of class `ListMap.Values`.
`private class`	`ListMap.XIterator`	Common superclass of iterators on key set, value collection and entries set providing all methods but `Iterator.next()`.

Field Summary

Fields
Modifier and Type	Field	Description
`private SortedSet<Map.Entry<K,V>>`	`entrySet`	The set of entries of this map returned by `entrySet()`.
`private ListSet<K>`	`keys`	The set of keys of this `ListMap`.
`private SortedSet<K>`	`keysSet`	The set of keys of this map returned by `keySet()`.
`private List<V>`	`values`	The values of this map.
`private Collection<V>`	`valuesColl`	The collection of values of this map returned by `values()`.

Constructor Summary

Constructors
Modifier	Constructor	Description
	`ListMap()`	Creates an empty list map with key set 'ordered as added' as described by `ListSet.sortedAsAdded()`.
`private`	`ListMap(ListSet<K> keys, List<V> values)`	Creates a list map defined by the given keys and values `keys` and `values`.
	`ListMap(Map<K,V> map)`	Creates an list map with the same key-value pairs as `map` and with ordering 'as added'.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`clear()`
`Comparator<? super K>`	`comparator()`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object val)`
`SortedSet<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object obj)`
`K`	`firstKey()`
`V`	`get(Object key)`
`int`	`hashCode()`
`ListMap<K,V>`	`headMap(K toKey)`
`boolean`	`isEmpty()`
`SortedSet<K>`	`keySet()`
`K`	`lastKey()`
`static void`	`main(String[] args)`
`private static <K,V> ListSet<K>`	`map2keys(Map<K,V> map)`	Returns the key set of `map` as a `ListSet` with ordering 'ordered as added' as given by `ListSet.sortedAsAdded()`.
`private static <K,V> List<V>`	`map2values(Map<K,V> map)`	Returns the value collection of `map` as a `List` with ordering given by the iteration on the key set of `map`.
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> other)`
`V`	`remove(Object key)`
`private boolean`	`removeIdx(int idx)`
`int`	`size()`
`(package private) ListMap<K,V>`	`subMap(int fromIdx, int toIdx)`
`ListMap<K,V>`	`subMap(K fromKey, K toKey)`
`ListMap<K,V>`	`tailMap(K fromKey)`
`String`	`toString()`
`Collection<V>`	`values()`

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

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

- Field Detail
  - keys
```
private final ListSet<K> keys
```
    The set of keys of this ListMap.
  - values
```
private final List<V> values
```
    The values of this map. The according keys are in keys.
  - valuesColl
```
private final Collection<V> valuesColl
```
    The collection of values of this map returned by values(). Note that each ListMap has a single values collection.
  - keysSet
```
private final SortedSet<K> keysSet
```
    The set of keys of this map returned by keySet(). Note that each ListMap has a single key set.
  - entrySet
```
private final SortedSet<Map.Entry<K,V>> entrySet
```
    The set of entries of this map returned by entrySet(). Note that each ListMap has a single entry set.
- Constructor Detail
  - ListMap
```
public ListMap()
```
    Creates an empty list map with key set 'ordered as added' as described by ListSet.sortedAsAdded().
  - ListMap
```
public ListMap(Map<K,V> map)
```
    Creates an list map with the same key-value pairs as map and with ordering 'as added'. If no additional keys are added, this reflects the ordering given by iterating through the key set of map.
    
    See Also:
    
    map2keys(Map), map2values(Map)
  - ListMap
```
private ListMap(ListSet<K> keys,
                List<V> values)
```
    Creates a list map defined by the given keys and values keys and values. A key and a value correspond iff their index coincides. Thus keys and values must have the same size. Note that the entries of keys differ pairwise, whereas this is not necessary for values.
    
    Parameters:
    
    keys - the set of keys as a ListSet.
    
    values - the collection of according values as a List with the same size as keys.
    
    Throws:
    
    IllegalArgumentException - if keys and values differ in size.
- Method Detail
  - map2keys
```
private static <K,V> ListSet<K> map2keys(Map<K,V> map)
```
    Returns the key set of map as a ListSet with ordering 'ordered as added' as given by ListSet.sortedAsAdded(). This ordering reflects the ordering given by the iteration on the key set of map.
  - map2values
```
private static <K,V> List<V> map2values(Map<K,V> map)
```
    Returns the value collection of map as a List with ordering given by the iteration on the key set of map. Note that there is no documentation **** that this ordering is the same as the one of the value collection map#values(). ****
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
  - containsValue
```
public boolean containsValue(Object val)
```
    Specified by:
    
    containsValue in interface Map<K,V>
  - entrySet
```
public SortedSet<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Specified by:
    
    entrySet in interface SortedMap<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
  - keySet
```
public SortedSet<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
    
    Specified by:
    
    keySet in interface SortedMap<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> other)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - removeIdx
```
private boolean removeIdx(int idx)
```
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
  - comparator
```
public Comparator<? super K> comparator()
```
    Specified by:
    
    comparator in interface SortedMap<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
    
    Specified by:
    
    values in interface SortedMap<K,V>
  - firstKey
```
public K firstKey()
```
    Specified by:
    
    firstKey in interface SortedMap<K,V>
  - lastKey
```
public K lastKey()
```
    Specified by:
    
    lastKey in interface SortedMap<K,V>
  - headMap
```
public ListMap<K,V> headMap(K toKey)
```
    Specified by:
    
    headMap in interface SortedMap<K,V>
  - tailMap
```
public ListMap<K,V> tailMap(K fromKey)
```
    Specified by:
    
    tailMap in interface SortedMap<K,V>
  - subMap
```
ListMap<K,V> subMap(int fromIdx,
                          int toIdx)
```
  - subMap
```
public ListMap<K,V> subMap(K fromKey,
                                 K toKey)
```
    Specified by:
    
    subMap in interface SortedMap<K,V>
  - equals
```
public boolean equals(Object obj)
```
    Specified by:
    
    equals in interface Map<K,V>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<K,V>
    
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - main
```
public static void main(String[] args)
```

Class ListMap<K,​V>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Field Detail

keys

values

valuesColl

keysSet

entrySet

Constructor Detail

ListMap

ListMap

ListMap

Method Detail

map2keys

map2values

clear

containsKey

containsValue

entrySet

get

isEmpty

keySet

put

putAll

remove

removeIdx

size

comparator

values

firstKey

lastKey

headMap

tailMap

subMap

subMap

equals

hashCode

toString

main

Class ListMap<K,V>