, ( ) Map. . Google API BiMap. , . !

Code:
// BiMap.java

package BiMap;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

public interface BiMap<K, V>
{
  public abstract void clear();
  public abstract boolean containsKey(Object key);
  public abstract boolean containsValue(Object value);
  public abstract V getValue(Object key);
  public abstract K getKey(Object value);
  public abstract boolean isEmpty();
  public abstract Set<K> keySet();
  public abstract V put(K key, V value);
  public abstract void putAll(Map<? extends K, ? extends V> m);
  public abstract V removeByKey(Object key);
  public abstract K removeByValue(Object value);
  public abstract int size();
  public abstract Collection<V> values();
}


// HashBiMap.java

package BiMap;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashBiMap<K, V> implements BiMap<K, V> 
{
  protected Map<K, V> keyValues;
  protected Map<V, K> valueKeys;
  
  public HashBiMap()
  {
    keyValues = new HashMap<K, V>();
    valueKeys = new HashMap<V, K>();
  }
  
  public HashBiMap(int initialCapacity) 
  {
    keyValues = new HashMap<K, V>(initialCapacity);
    valueKeys = new HashMap<V, K>(initialCapacity);
  }
  
  public HashBiMap(int initialCapacity, float loadFactor) 
  {
    keyValues = new HashMap<K, V>(initialCapacity, loadFactor);
    valueKeys = new HashMap<V, K>(initialCapacity, loadFactor);
  }
  
  public void clear() 
  {
    keyValues.clear();
    valueKeys.clear();
  }

  public boolean containsKey(Object key) 
  {
    return keyValues.containsKey(key);
  }

  public boolean containsValue(Object value) 
  {
    return valueKeys.containsKey(value);
  }

  public K getKey(Object value) 
  {
    return valueKeys.get(value);
  }

  public V getValue(Object key) 
  {
    return keyValues.get(key);
  }

  public boolean isEmpty() 
  {
    return keyValues.isEmpty();
  }

  public Set<K> keySet() 
  {
    return keyValues.keySet();
  }

  public V put(K key, V value) 
  {
    V prev = keyValues.put(key, value);
    valueKeys.put(value, key);
    
    return prev;
  }

  public void putAll(Map<? extends K, ? extends V> m) 
  {
    for (K key : m.keySet())
    {
      put(key, m.get(key));
    }
  }

  public V removeByKey(Object key) 
  {
    V prev = keyValues.remove(key);
    valueKeys.remove(prev);
    
    return prev;
  }

  public K removeByValue(Object value) 
  {
    K prev = valueKeys.remove(value);
    keyValues.remove(prev);
    
    return prev;
  }

  public int size() 
  {
    return keyValues.size();
  }

  public Collection<V> values() 
  {
    return keyValues.values();
  }
}