public static class Internal.MapAdapter<K,V,RealValue> extends AbstractMap<K,V>
Map<K, RealValue> and provide a Map<K, V> interface.| Modifier and Type | Class and Description |
|---|---|
static interface |
Internal.MapAdapter.Converter<A,B>
An interface used to convert between two types.
|
AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>| Constructor and Description |
|---|
MapAdapter(Map<K,RealValue> realMap,
Internal.MapAdapter.Converter<RealValue,V> valueConverter) |
| Modifier and Type | Method and Description |
|---|---|
Set<Map.Entry<K,V>> |
entrySet()
Returns a
Set view of the mappings contained in this map. |
V |
get(Object key)
Returns the value to which the specified key is mapped, or
null if this map contains no
mapping for the key. |
static <T extends Internal.EnumLite> |
newEnumConverter(Internal.EnumLiteMap<T> enumMap,
T unrecognizedValue) |
V |
put(K key,
V value)
Associates the specified value with the specified key in this map (optional operation).
|
clear, clone, containsKey, containsValue, equals, hashCode, isEmpty, keySet, putAll, remove, size, toString, valuespublic Set<Map.Entry<K,V>> entrySet()
MapSet view of the mappings contained in this map. The set is backed by the map,
so changes to the map are reflected in the set, and vice-versa. If the map is modified while an
iteration over the set is in progress (except through the iterator's own remove
operation, or through the setValue operation on a map entry returned by the iterator)
the results of the iteration are undefined. The set supports element removal, which removes the
corresponding mapping from the map, via the Iterator.remove, Set.remove,
removeAll, retainAll and clear operations. It does not support the
add or addAll operations.@Nullable public V get(Object key)
AbstractMapnull if this map contains no
mapping for the key.
More formally, if this map contains a mapping from a key k to a value v such that
(key==null ? k==null :
key.equals(k)), then this method returns v; otherwise it returns null. (There
can be at most one such mapping.)
If this map permits null values, then a return value of null does not necessarily
indicate that the map contains no mapping for the key; it's also possible that the map explicitly
maps the key to null. The containsKey operation may be used to
distinguish these two cases.
This implementation iterates over entrySet() searching for an entry with the specified
key. If such an entry is found, the entry's value is returned. If the iteration terminates
without finding such an entry, null is returned. Note that this implementation requires
linear time in the size of the map; many implementations will override this method.
public static <T extends Internal.EnumLite> Internal.MapAdapter.Converter<Integer,T> newEnumConverter(Internal.EnumLiteMap<T> enumMap, T unrecognizedValue)
@Nullable public V put(K key, V value)
AbstractMapm is said to contain a mapping for a key k if and only if
m.containsKey(k) would return true.)
This implementation always throws an UnsupportedOperationException.
put in interface Map<K,V>put in class AbstractMap<K,V>key - key with which the specified value is to be associatedvalue - value to be associated with the specified keykey, or null if there was no mapping
for key. (A null return can also indicate that the map previously
associated null with key, if the implementation supports null
values.)