Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.google.common.collect
Class EnumBiMap<K extends Enum<K>,V extends Enum<V>>

    java.lang.Object
      com.google.common.collect.ForwardingObject
          com.google.common.collect.ForwardingMap<K,V>
              com.google.common.collect.EnumBiMap<K,V>

All Implemented Interfaces:
  BiMap<K,V>, Serializable, Map<K,V>

    public final class EnumBiMap<K extends Enum<K>,V extends Enum<V>>

extends ForwardingMap<K,V>

A `BiMap` backed by two `EnumMap` instances. Null keys and values are not permitted. An `EnumBiMap` and its inverse are both serializable.

Author:
  Mike Bostock
See Also:
  Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map
`Map.Entry<K,V>`

Method Summary
`void` | `clear()` Removes all of the mappings from this map (optional operation).
`boolean` | `containsValue(Object value)` Returns `true` if this map maps one or more keys to the specified value.
`static
`<K extends Enum<K>,V extends Enum<V>> EnumBiMap<K,V>`
` | `create(Class<K> keyType, Class<V> valueType)` Returns a new, empty `EnumBiMap` using the specified key and value types.
`static
`<K extends Enum<K>,V extends Enum<V>> EnumBiMap<K,V>`
` | `create(Map<K,V> map)` Returns a new bimap with the same mappings as the specified map.
`protected Map<K,V>` | `delegate()` Returns the backing delegate instance that methods are forwarded to.
`Set<Map.Entry<K,V>>` | `entrySet()` Returns a `Set` view of the mappings contained in this map.
`V` | `forcePut(K key, V value)` An alternate form of `put` that silently removes any existing entry with the value `value` before proceeding with the `BiMap.put(K, V)` operation.
`BiMap<V,K>` | `inverse()` Returns the inverse view of this bimap, which maps each of this bimap's values to its associated key.
`Set<K>` | `keySet()` Returns a `Set` view of the keys contained in this map.
`Class<K>` | `keyType()` Returns the associated key type.
`V` | `put(K key, V value)` Associates the specified value with the specified key in this map (optional operation).
`void` | `putAll(Map<? extends K,? extends V> map)` Copies all of the mappings from the specified map to this map (optional operation).
`V` | `remove(Object key)` Removes the mapping for a key from this map if it is present (optional operation).
`Set<V>` | `values()` Returns a `Collection` view of the values contained in this map.
`Class<V>` | `valueType()` Returns the associated value type.

Methods inherited from class com.google.common.collect.ForwardingMap
`containsKey, equals, get, hashCode, isEmpty, size`

Methods inherited from class com.google.common.collect.ForwardingObject
`toString`

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

Methods inherited from interface java.util.Map
`containsKey, equals, get, hashCode, isEmpty, size`

Method Detail

### create

    public static <K extends Enum<K>,V extends Enum<V>> EnumBiMap<K,V> create(Class<K> keyType,
                                                                              Class<V> valueType)

  Returns a new, empty `EnumBiMap` using the specified key and value types.

  Parameters:
    `keyType` - the key type
    `valueType` - the value type

### create

    public static <K extends Enum<K>,V extends Enum<V>> EnumBiMap<K,V> create(Map<K,V> map)

  Returns a new bimap with the same mappings as the specified map. If the specified map is an `EnumBiMap`, the new bimap has the same types as the provided map. Otherwise, the specified map must contain at least one mapping, in order to determine the key and value types.

  Parameters:
    `map` - the map whose mappings are to be placed in this map
  Throws:
    `IllegalArgumentException` - if map is not an `EnumBiMap` instance and contains no mappings

### keyType

    public Class<K> keyType()

  Returns the associated key type.

### valueType

    public Class<V> valueType()

  Returns the associated value type.

### delegate

    protected Map<K,V> delegate()

  Description copied from class: `ForwardingObject`
  Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as `ForwardingSet.delegate()`. Concrete subclasses override this method to supply the instance being decorated.

  Specified by:
    `delegate` in class `ForwardingMap<K,V>`

### containsValue

    public boolean containsValue(Object value)

  Description copied from interface: `java.util.Map`
  Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `(value==null ? v==null : value.equals(v))`. This operation will probably require time linear in the map size for most implementations of the `Map` interface.

  Specified by:
    `containsValue` in interface `Map<K,V>`
  Overrides:
    `containsValue` in class `ForwardingMap<K,V>`
  Parameters:
    `value` - value whose presence in this map is to be tested
  Returns:
    `true` if this map maps one or more keys to the specified value

### put

    public V put(K key,
                 V value)

  Description copied from interface: `java.util.Map`
  Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for the key, the old value is replaced by the specified value. (A map `m` is said to contain a mapping for a key `k` if and only if `m.containsKey(k)` would return `true`.)

  Specified by:
    `put` in interface `BiMap<K,V>`
  Specified by:
    `put` in interface `Map<K,V>`
  Overrides:
    `put` in class `ForwardingMap<K,V>`
  Parameters:
    `key` - key with which the specified value is to be associated
    `value` - value to be associated with the specified key
  Returns:
    the previous value associated with `key`, 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.)

### forcePut

    public V forcePut(K key,
                      V value)

  Description copied from interface: `BiMap`
  An alternate form of `put` that silently removes any existing entry with the value `value` before proceeding with the `BiMap.put(K, V)` operation. If the bimap previously contained the provided key-value mapping, this method has no effect.

  Note that a successful call to this method could cause the size of the bimap to increase by one, stay the same, or even decrease by one.

  Warning: If an existing entry with this value is removed, the key for that entry is discarded and not returned.

  Specified by:
    `forcePut` in interface `BiMap<K,V>`
  Parameters:
    `key` - the key with which the specified value is to be associated
    `value` - the value to be associated with the specified key
  Returns:
    the value which was previously associated with the key, which may be `null`, or `null` if there was no previous entry

### remove

    public V remove(Object key)

  Description copied from interface: `java.util.Map`
  Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `(key==null ? k==null : key.equals(k))`, that mapping is removed. (The map can contain at most one such mapping.)

  Returns the value to which this map previously associated the key, or `null` if the map contained no mapping for the key.

  If this map permits null values, then a return value of `null` does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to `null`.

  The map will not contain a mapping for the specified key once the call returns.

  Specified by:
    `remove` in interface `Map<K,V>`
  Overrides:
    `remove` in class `ForwardingMap<K,V>`
  Parameters:
    `key` - key whose mapping is to be removed from the map
  Returns:
    the previous value associated with `key`, or `null` if there was no mapping for `key`.

### putAll

    public void putAll(Map<? extends K,? extends V> map)

  Description copied from interface: `java.util.Map`
  Copies all of the mappings from the specified map to this map (optional operation). The effect of this call is equivalent to that of calling `put(k, v)` on this map once for each mapping from key `k` to value `v` in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.

  Specified by:
    `putAll` in interface `BiMap<K,V>`
  Specified by:
    `putAll` in interface `Map<K,V>`
  Overrides:
    `putAll` in class `ForwardingMap<K,V>`
  Parameters:
    `map` - mappings to be stored in this map

### clear

    public void clear()

  Description copied from interface: `java.util.Map`
  Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.

  Specified by:
    `clear` in interface `Map<K,V>`
  Overrides:
    `clear` in class `ForwardingMap<K,V>`

### inverse

    public BiMap<V,K> inverse()

  Description copied from interface: `BiMap`
  Returns the inverse view of this bimap, which maps each of this bimap's values to its associated key. The two bimaps are backed by the same data; any changes to one will appear in the other.

  Note:There is no guaranteed correspondence between the iteration order of a bimap and that of its inverse.

  Specified by:
    `inverse` in interface `BiMap<K,V>`
  Returns:
    the inverse view of this bimap

### keySet

    public Set<K> keySet()

  Description copied from interface: `java.util.Map`
  Returns a `Set` view of the keys 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), 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.

  Specified by:
    `keySet` in interface `Map<K,V>`
  Overrides:
    `keySet` in class `ForwardingMap<K,V>`
  Returns:
    a set view of the keys contained in this map

### values

    public Set<V> values()

  Description copied from interface: `java.util.Map`
  Returns a `Collection` view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.

  Specified by:
    `values` in interface `BiMap<K,V>`
  Specified by:
    `values` in interface `Map<K,V>`
  Overrides:
    `values` in class `ForwardingMap<K,V>`
  Returns:
    a collection view of the values contained in this map

### entrySet

    public Set<Map.Entry<K,V>> entrySet()

  Description copied from interface: `java.util.Map`
  Returns a `Set` 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.

  Specified by:
    `entrySet` in interface `Map<K,V>`
  Overrides:
    `entrySet` in class `ForwardingMap<K,V>`
  Returns:
    a set view of the mappings contained in this map

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD