public class ListOrderedMap<K,V> extends AbstractMapDecorator<K ,V> implements OrderedMap <K ,V>, Serializable
Map to ensure that the order of addition is retained using a
List to maintain order.
The order will be used via the iterators and toArray methods on the views. The order is also returned by the MapIterator. The orderedMapIterator() method accesses an iterator that can iterate both forwards and backwards through the map. In addition, non-interface methods are provided to access the map by index.
If an object is added to the Map for a second time, it will remain in the original position in the iteration.
Note that ListOrderedMap is not synchronized and is not thread-safe. If you wish to use this map from multiple threads concurrently, you must use appropriate synchronization. The simplest approach is to wrap this map using Collections. This class may throw exceptions when accessed by concurrent threads without synchronization.
Note that ListOrderedMap doesn't work with IdentityHashMap, CaseInsensitiveMap, or similar maps that violate the general contract of Map. The ListOrderedMap (or, more precisely, the underlying List) is relying on equals(). This is fine, as long as the decorated Map is also based on equals(), and hashCode(), which IdentityHashMap, and CaseInsensitiveMap don't: The former uses ==, and the latter uses equals() on a lower-cased key.
This class is Serializable starting with Commons Collections 3.1.
| Modifier | Constructor and Description |
|---|---|
|
ListOrderedMap()
Constructs a new empty
ListOrderedMap that decorates a
HashMap.
|
protected |
ListOrderedMap(Map
Constructor that wraps (not copies).
|
| Modifier and Type | Method and Description |
|---|---|
List |
asList()
Gets an unmodifiable List view of the keys which changes as the map changes.
|
void |
clear()
|
Set |
entrySet()
Gets a view over the entries in the map.
|
K |
firstKey()
Gets the first key in this map by insert order.
|
K |
get(int index)
Gets the key at the specified index.
|
V |
getValue(int index)
Gets the value at the specified index.
|
int |
indexOf(Object
Gets the index of the specified key.
|
List |
keyList()
Gets a view over the keys in the map as a List.
|
Set |
keySet()
Gets a view over the keys in the map.
|
K |
lastKey()
Gets the last key in this map by insert order.
|
static <K |
listOrderedMap(Map
Factory method to create an ordered map.
|
OrderedMapIterator |
mapIterator()
Obtains a
MapIterator over the map.
|
K |
nextKey(Object
Gets the next key to the one specified using insert order.
|
K |
previousKey(Object
Gets the previous key to the one specified using insert order.
|
V |
put(int index, K key, V value)
Puts a key-value mapping into the map at the specified index.
|
V |
put(K key, V value)
Note that the return type is Object, rather than V as in the Map interface.
|
void |
putAll(int index, Map
Puts the values contained in a supplied Map into the Map starting at the specified index.
|
void |
putAll(Map
|
V |
remove(int index)
Removes the element at the specified index.
|
V |
remove(Object
|
V |
setValue(int index, V value)
Sets the value at the specified index.
|
String |
toString()
Returns the Map as a string.
|
List |
valueList()
Gets a view over the values in the map as a List.
|
Collection |
values()
Gets a view over the values in the map.
|
containsKey, containsValue, decorated, equals, get, hashCode, isEmpty, sizeclone, finalize, getClass, notify, notifyAll, wait, wait, waitcompute, computeIfAbsent, computeIfPresent, containsKey, containsValue, equals, forEach, get, getOrDefault, hashCode, isEmpty, merge, putIfAbsent, remove, replace, replace, replaceAll, sizecontainsKey, containsValue, get, isEmpty, sizepublic ListOrderedMap()
ListOrderedMap that decorates a
HashMap.
protected ListOrderedMap(Map<K ,V> map)
map - the map to decorate, must not be null
NullPointerException - if map is null
public static <K,V> ListOrderedMap <K ,V> listOrderedMap(Map <K ,V> map)
An ArrayList is used to retain order.
K - the key type
V - the value type
map - the map to decorate, must not be null
NullPointerException - if map is null
public OrderedMapIterator<K ,V> mapIterator()
AbstractIterableMap
MapIterator over the map.
A map iterator is an efficient way of iterating over maps. There is no need to access the entry set or use Map Entry objects.
IterableMap
map = new HashedMap
(); MapIterator
it = map.mapIterator(); while (it.hasNext()) { String key = it.next(); Integer value = it.getValue(); it.setValue(value + 1); }
mapIterator in interface
IterableGet<K,V>
mapIterator in interface
OrderedMap<K,V>
mapIterator in class
AbstractIterableMap<K,V>
public K firstKey()
firstKey in interface
OrderedMap<K,V>
NoSuchElementException - if this map is empty
public K lastKey()
lastKey in interface
OrderedMap<K,V>
NoSuchElementException - if this map is empty
public K nextKey(Objectkey)
nextKey in interface
OrderedMap<K,V>
key - the key to find previous for
public K previousKey(Objectkey)
previousKey in interface
OrderedMap<K,V>
key - the key to find previous for
public V put(K key, V value)
Put
public void putAll(int index,
Map<? extends K,? extends V> map)
index - the index in the Map to start at.
map - the Map containing the entries to be added.
IndexOutOfBoundsException - if the index is out of range [0, size]
public void clear()
public Set<K> keySet()
The Collection will be ordered by object insertion into the map.
public List<K> keyList()
The List will be ordered by object insertion into the map. The List is unmodifiable.
keySet()
public Collection<V> values()
The Collection will be ordered by object insertion into the map.
From Commons Collections 3.2, this Collection can be cast to a list, see valueList()
public List<V> valueList()
The List will be ordered by object insertion into the map. The List supports remove and set, but does not support add.
values()
public Set<Map .Entry <K ,V>> entrySet()
The Set will be ordered by object insertion into the map.
public StringtoString()
toString in class
AbstractMapDecorator<K,V>
public K get(int index)
index - the index to retrieve
IndexOutOfBoundsException - if the index is invalid
public V getValue(int index)
index - the index to retrieve
IndexOutOfBoundsException - if the index is invalid
public int indexOf(Objectkey)
key - the key to find the index of
public V setValue(int index, V value)
index - the index of the value to set
value - the new value to set
IndexOutOfBoundsException - if the index is invalid
public V put(int index, K key, V value)
If the map already contains the key, then the original mapping is removed and the new mapping added at the specified index. The remove may change the effect of the index. The index is always calculated relative to the original state of the map.
Thus the steps are: (1) remove the existing key-value mapping, then (2) insert the new key-value mapping at the position it would have been inserted had the remove not occurred.
index - the index at which the mapping should be inserted
key - the key
value - the value
IndexOutOfBoundsException - if the index is out of range [0, size]
public V remove(int index)
index - the index of the object to remove
null if none existed
IndexOutOfBoundsException - if the index is invalid
public List<K> asList()
The returned list is unmodifiable because changes to the values of the list (using ListIterator) will effectively remove the value from the list and reinsert that value at the end of the list, which is an unexpected side effect of changing the value of a list. This occurs because changing the key, changes when the mapping is added to the map and thus where it appears in the list.
An alternative to this method is to use the better named keyList() or keySet().