java Map根据value得到key值

Map提供了根据key取得value的方法， get(value)  这是唯一对应的（如果存在），即一个key只会对应到一个value。但是Java类库没有提供Map根据value取得key的方法。所以需要自己实现，两种方法：

 

一.   直接根据value取得key（可能有多个）

import java.util.*;

/**
 * @version 14.1.8
 * @author Administrator
 * @see 在map中根据value值取得key值
 */
public class Map_ValueGetKey {
	HashMap map;

	public Map_ValueGetKey(HashMap map) { // 初始化操作
		this.map = map;
	}

	public Object getKey(Object value) {
		Object o = null;
		ArrayList all = new ArrayList(); // 建一个数组用来存放符合条件的KEY值

		/*
		 * 这里关键是那个entrySet()的方法,它会返回一个包含Map.Entry集的Set对象.
		 * Map.Entry对象有getValue和getKey的方法,利用这两个方法就可以达到从值取键的目的了 *
		 */

		Set set = map.entrySet();
		Iterator it = set.iterator();
		while (it.hasNext()) {
			Map.Entry entry = (Map.Entry) it.next();
			if (entry.getValue().equals(value)) {
				o = entry.getKey();
				all.add(o); // 把符合条件的项先放到容器中,下面再一次性打印出
			}
		}
		return all;
	}

	public static void main(String[] args) {
		HashMap map = new HashMap();
		map.put("1", "a");
		map.put("2", "b");
		map.put("3", "c");
		map.put("4", "c");
		map.put("5", "e");
		Map_ValueGetKey mvg = new Map_ValueGetKey(map);
		System.out.println(mvg.getKey("c"));
	}

}

二.新建一个value为key 的Map类继承自 HashMap，覆盖一些方法：

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @see 建立一个value HashMap类
 * @author Administrator
 *
 * @param <K>
 * @param <V>
 */
public class ValueHashMap<K, V> extends HashMap<K, V> {

    private static final long serialVersionUID = 4136683943755968213L;

    protected Map<V, Set<K>> valueMap;

    protected boolean isDebug = false;

    public ValueHashMap() {
        super();
        initValueMap();
    }

    public ValueHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        initValueMap();
    }

    public ValueHashMap(int initialCapacity) {
        super(initialCapacity);
        initValueMap();
    }

    public ValueHashMap(Map<? extends K, ? extends V> m) {
        super(m);
        initValueMap();
    }

    private void initValueMap() {
        valueMap = new HashMap<V, Set<K>>();
    }

    @Override
    public void clear() {
        super.clear();
        valueMap.clear();
    }

    @Override
    public V put(K key, V value) {
        V v = super.put(key, value);
        putValue(key, value);
        debugValueMap(key, value);
        return v;
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        super.putAll(m);
        for(Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
            putValue(entry.getKey(), entry.getValue());
            debugValueMap(entry.getKey(), entry.getValue());
        }        
    }

    @Override
    public V remove(Object key) {
        if(!containsKey(key)) {
            return null;
        }
        V v = super.remove(key);
        removeValueMapKey(key, v);
        debugValueMap(key, null);
        return v;
    }

    public Set<K> getKeySet(V value) {
        return Collections.unmodifiableSet(valueMap.get(value)); //将得到的Set设置为不可变的
    }

    protected void putValue(K key, V value) {
        Set<K> keys = valueMap.get(value);
        if(keys == null) {
            keys = new HashSet<K>();
            valueMap.put(value, keys);
        }
        keys.add(key);
    }

    protected void removeValueMapKey(Object key, V value) {
        valueMap.get(value).remove(key);
    }

    protected void debugValueMap(Object key, V value) {
        if(!isDebug) {
            return;
        }
        StackTraceElement se = new Throwable().getStackTrace()[1];
        System.out.print(se.getMethodName() + ": ");
        System.out.print("key = [" + key + "]");
        if(!"remove".equals(se.getMethodName())) {
            System.out.print(", value = [" + value + "]");
        }
        System.out.println();
        for(Map.Entry<V, Set<K>> en : valueMap.entrySet()) {
            System.out.print("  [" + en.getKey() + "] --> ");
            int i = 0;
            for(K k : en.getValue()) {
                if(i++ > 0) {
                    System.out.print(", ");
                }
                System.out.print("[" + k + "]");
            }
            System.out.println();
        }
        System.out.println();
    }
}

 

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

/**
 * @version 14.1.8
 * @author Administrator
 * @see 测试类   测试ValueHashMap
 */
public class ValueHashMapTest {

    public static void main(String[] args) {
        Map<String, String> map = new ValueHashMap<String, String>();
        map.put("1", "1-1");
        map.put("2", "1-1");
        map.put("3", "1-1");
        map.put("4", "1-1");

        map.put("5", null);
        map.put("6", null);
        map.put("7", null);
        map.put("8", null);
        map.put("9", null);

        map.remove("9");

        ValueHashMap<String, String> vmap = (ValueHashMap<String, String>)map;

        vmap.put("10", null);

        vmap.remove("8");

        vmap.remove("a");

        vmap.put(null, null);

        Map<String, String> t = new HashMap<String, String>();
        t.put("b", null);
        t.put("c", null);
        t.put("d", "1-2");

        Set<String> keys = vmap.getKeySet(null);
        System.out.println("输出value为null的key");
        for(String str : keys) {
            System.out.println(str);
        }

        Set<String> keys2 =vmap.getKeySet("1-1");
        System.out.println("输出value为"+"1-1"+"的key");
        for(String str2 : keys2){
        	System.out.println(str2);
        }
    }
}