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
Interface BiMap<K,V>

All Superinterfaces:
  Map<K,V>

All Known Implementing Classes:
  EnumBiMap, EnumHashBiMap, HashBiMap, ImmutableBiMap

    public interface BiMap<K,V>

extends Map<K,V>

A bimap (or "bidirectional map") is a map that preserves the uniqueness of its values as well as that of its keys. This constraint enables bimaps to support an "inverse view", which is another bimap containing the same entries as this bimap but with reversed keys and values.

Author:
  Kevin Bourrillion

Nested Class Summary

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

Method Summary
`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 `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.
`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).
`Set<V>` | `values()` Returns a `Collection` view of the values contained in this map.

Methods inherited from interface java.util.Map
`clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, remove, size`

Method Detail

### put

    V put(@Nullable
          K key,
          @Nullable
          V value)

  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 `Map<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.)
  Throws:
    `IllegalArgumentException` - if the given value is already bound to a different key in this bimap. The bimap will remain unmodified in this event. To avoid this exception, call `forcePut(K, V)` instead.

### forcePut

    V forcePut(@Nullable
               K key,
               @Nullable
               V value)

  An alternate form of `put` that silently removes any existing entry with the value `value` before proceeding with the `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.

  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

### putAll

    void putAll(Map<? extends K,? extends V> 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.

  Warning: the results of calling this method may vary depending on the iteration order of `map`.

  Specified by:
    `putAll` in interface `Map<K,V>`
  Parameters:
    `map` - mappings to be stored in this map
  Throws:
    `IllegalArgumentException` - if an attempt to `put` any entry fails. Note that some map entries may have been added to the bimap before the exception was thrown.

### values

    Set<V> values()

  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.

  Because a bimap has unique values, this method returns a `Set`, instead of the `Collection` specified in the `Map` interface.

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

### inverse

    BiMap<V,K> inverse()

  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.

  Returns:
    the inverse view of this bimap

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