java.util

Class EnumMap<K,extends,Enum,K,V>

Implemented Interfaces:
Cloneable, Map<K,V>, Serializable

public class EnumMap<K,extends,Enum,K,V>
extends AbstractMap<K,V>
implements Cloneable, Serializable

Since:
1.5
See Also:
Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class java.util.AbstractMap<K,V>

AbstractMap.SimpleEntry, AbstractMap.SimpleImmutableEntry

Constructor Summary

EnumMap(Class keyType)
EnumMap(EnumMap map)
EnumMap(Map map)

Method Summary

EnumMap
V> clone()
Set
V>> entrySet()
Returns a set view of the mappings in this Map.
void
clear()
Remove all entries from this Map (optional operation).
boolean
containsKey(Object key)
Returns true if this contains a mapping for the given key.
boolean
containsValue(Object value)
Returns true if this contains at least one mapping with the given value.
boolean
equals(Object o)
Compares the specified object with this map for equality.
V
get(Object key)
Returns the value mapped by the given key.
Set
keySet()
Returns a set view of this map's keys.
V
put(K key, V value)
Associates the given key to the given value (optional operation).
void
putAll(extends K, V> map)
Copies all entries of the given map to this one (optional operation).
V
remove(Object key)
Removes the mapping for this key if present (optional operation).
int
size()
Returns the number of key-value mappings in the map.
Collection
values()
Returns a collection or bag view of this map's values.

Methods inherited from class java.util.AbstractMap<K,V>

V>> entrySet, clear, clone, containsKey, containsValue, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, toString, values

Methods inherited from class java.lang.Object

clone, equals, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

EnumMap

public EnumMap(Class keyType)

EnumMap

public EnumMap(EnumMap map)

EnumMap

public EnumMap(Map map)

Method Details

V> clone

public EnumMapV> clone()

V>> entrySet

public SetV>> entrySet()
Returns a set view of the mappings in this Map. Each element in the set must be an implementation of Map.Entry. The set is backed by the map, so that changes in one show up in the other. Modifications made while an iterator is in progress cause undefined behavior. If the set supports removal, these methods must be valid: Iterator.remove, Set.remove, removeAll, retainAll, and clear. Element addition is not supported via this set.
Specified by:
V>> entrySet in interface Map<K,V>
Overrides:
V>> entrySet in interface AbstractMap<K,V>
Returns:
the entry set
See Also:
Map.Entry

clear

public void clear()
Remove all entries from this Map (optional operation). This default implementation calls entrySet().clear(). NOTE: If the entry set does not permit clearing, then this will fail, too. Subclasses often override this for efficiency. Your implementation of entrySet() should not call AbstractMap.clear unless you want an infinite loop.
Specified by:
clear in interface Map<K,V>
Overrides:
clear in interface AbstractMap<K,V>
Throws:
UnsupportedOperationException - if entrySet().clear() does not support clearing.
See Also:
Set.clear()

containsKey

public boolean containsKey(Object key)
Returns true if this contains a mapping for the given key. This implementation does a linear search, O(n), over the entrySet(), returning true if a match is found, false if the iteration ends. Many subclasses can implement this more efficiently.
Specified by:
containsKey in interface Map<K,V>
Overrides:
containsKey in interface AbstractMap<K,V>
Parameters:
key - the key to search for
Returns:
true if the map contains the key
Throws:
NullPointerException - if key is null but the map does not permit null keys

containsValue

public boolean containsValue(Object value)
Returns true if this contains at least one mapping with the given value. This implementation does a linear search, O(n), over the entrySet(), returning true if a match is found, false if the iteration ends. A match is defined as a value, v, where (value == null ? v == null : value.equals(v)). Subclasses are unlikely to implement this more efficiently.
Specified by:
containsValue in interface Map<K,V>
Overrides:
containsValue in interface AbstractMap<K,V>
Parameters:
value - the value to search for
Returns:
true if the map contains the value

equals

public boolean equals(Object o)
Compares the specified object with this map for equality. Returns true if the other object is a Map with the same mappings, that is,
o instanceof Map && entrySet().equals(((Map) o).entrySet();
Specified by:
equals in interface Map<K,V>
Overrides:
equals in interface AbstractMap<K,V>
Parameters:
o - the object to be compared
Returns:
true if the object equals this map

get

public V get(Object key)
Returns the value mapped by the given key. Returns null if there is no mapping. However, in Maps that accept null values, you must rely on containsKey to determine if a mapping exists. This iteration takes linear time, searching entrySet().iterator() of the key. Many implementations override this method.
Specified by:
get in interface Map<K,V>
Overrides:
get in interface AbstractMap<K,V>
Parameters:
key - the key to look up
Returns:
the value associated with the key, or null if key not in map
Throws:
NullPointerException - if this map does not accept null keys

keySet

public Set keySet()
Returns a set view of this map's keys. The set is backed by the map, so changes in one show up in the other. Modifications while an iteration is in progress produce undefined behavior. The set supports removal if entrySet() does, but does not support element addition.

This implementation creates an AbstractSet, where the iterator wraps the entrySet iterator, size defers to the Map's size, and contains defers to the Map's containsKey. The set is created on first use, and returned on subsequent uses, although since no synchronization occurs, there is a slight possibility of creating two sets.

Specified by:
keySet in interface Map<K,V>
Overrides:
keySet in interface AbstractMap<K,V>
Returns:
a Set view of the keys

put

public V put(K key,
             V value)
Associates the given key to the given value (optional operation). If the map already contains the key, its value is replaced. This implementation simply throws an UnsupportedOperationException. Be aware that in a map that permits null values, a null return does not always imply that the mapping was created.
Specified by:
put in interface Map<K,V>
Overrides:
put in interface AbstractMap<K,V>
Parameters:
key - the key to map
value - the value to be mapped
Returns:
the previous value of the key, or null if there was no mapping
Throws:
UnsupportedOperationException - if the operation is not supported
ClassCastException - if the key or value is of the wrong type
IllegalArgumentException - if something about this key or value prevents it from existing in this map
NullPointerException - if the map forbids null keys or values

putAll

public void putAll(extends K,
                   V> map)
Copies all entries of the given map to this one (optional operation). If the map already contains a key, its value is replaced. This implementation simply iterates over the map's entrySet(), calling put, so it is not supported if puts are not.
Specified by:
putAll in interface Map<K,V>
Overrides:
putAll in interface AbstractMap<K,V>
Parameters:
Throws:
UnsupportedOperationException - if the operation is not supported by this map.
ClassCastException - if a key or value is of the wrong type for adding to this map.
IllegalArgumentException - if something about a key or value prevents it from existing in this map.
NullPointerException - if the map forbids null keys or values.
NullPointerException - if m is null.
See Also:
put(Object, Object)

remove

public V remove(Object key)
Removes the mapping for this key if present (optional operation). This implementation iterates over the entrySet searching for a matching key, at which point it calls the iterator's remove method. It returns the result of getValue() on the entry, if found, or null if no entry is found. Note that maps which permit null values may also return null if the key was removed. If the entrySet does not support removal, this will also fail. This is O(n), so many implementations override it for efficiency.
Specified by:
remove in interface Map<K,V>
Overrides:
remove in interface AbstractMap<K,V>
Parameters:
key - the key to remove
Returns:
the value the key mapped to, or null if not present. Null may also be returned if null values are allowed in the map and the value of this mapping is null.
Throws:
UnsupportedOperationException - if deletion is unsupported

size

public int size()
Returns the number of key-value mappings in the map. If there are more than Integer.MAX_VALUE mappings, return Integer.MAX_VALUE. This is implemented as entrySet().size().
Specified by:
size in interface Map<K,V>
Overrides:
size in interface AbstractMap<K,V>
Returns:
the number of mappings
See Also:
Set.size()

values

public Collection values()
Returns a collection or bag view of this map's values. The collection is backed by the map, so changes in one show up in the other. Modifications while an iteration is in progress produce undefined behavior. The collection supports removal if entrySet() does, but does not support element addition.

This implementation creates an AbstractCollection, where the iterator wraps the entrySet iterator, size defers to the Map's size, and contains defers to the Map's containsValue. The collection is created on first use, and returned on subsequent uses, although since no synchronization occurs, there is a slight possibility of creating two collections.

Specified by:
values in interface Map<K,V>
Overrides:
values in interface AbstractMap<K,V>
Returns:
a Collection view of the values

EnumMap.java - Map where keys are enum constants Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version.