又不是一对一的关系,一个Key对应一个value,但一个value却可以对应多个key。java绝对不支持这方法,你可以手动写一个,但可能返回多个key

解决方案 »

  1.   

    楼主可以看看哈希算法相关的一些东西..如果要从value到key, 必须做一些自己的处理的.
      

  2.   

    只能遍历整个map,比如
    value="test123";
    Set<String>kset=map.keySet();
    for(String ks:kset){
        if(value.equals(map.get(ks)){
             System.out.println(ks);
        }
    }
      

  3.   

    Map中是没有这样的实现方法..可能有多个key的值是一样的..
      

  4.   


    HashMap map = new HashMap();
    map.put("1", "11");
    map.put("2", "22");
    map.put("3", "33");
    map.put("4", "44");
    map.put("5", "55");
    map.put("6", "66");
    map.put("7", "77");
    int num = 0 ;
    String key;
    String value;
    Iterator it1 = map.keySet().iterator();
    Iterator it2 = map.entrySet().iterator();

    while(it2.hasNext()){
    num++;
    value = ((Object) it2.next()).toString(); 
    if("55".equals(value))
    break;
    } System.out.println("num = " + num);
    while(it1.hasNext()){
    num--;
    value = (String) it1.next(); 
    if(num ==0){
    System.out.println("value = " + value);
    break;
    }
    }
    楼主  你运行下上面的代码会发现美办法实现你说的那个通过value找key的功能
    原因是 key和value都是set类型的   而set类型存放的数据本身就是无序的
    所以你没办法对应上。
      

  5.   

    遍历就行了,一个value可能对应多个key,所以结果应该放到数组或者集合里
      

  6.   

    把value和key加到一个新map里,重复的key用list存放。
    新的map的结构是:map<value,list<key>>
      

  7.   

    继承 HashMap,覆盖一些方法:import java.util.Collections;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;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>>();
        }    public void clear() {
            super.clear();
            valueMap.clear();
        }    public V put(K key, V value) {
            V v = super.put(key, value);
            putValue(key, value);
            debugValueMap(key, value);
            return v;
        }    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());
            }        
        }    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));
        }
        
        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;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);
            for(String str : keys) {
                System.out.println(str);
            }
        }
    }
      

  8.   


    我见好多程序都用这样的写法。不错。HashMap 易插易读。正在研究内部结构
      

  9.   

    果子的generic让我。。
    晕以前学C++的时候就对template比较晕,现在java也来了。。我还是很晕
      

  10.   

    看到这个  protected Map<V, Set<K>> valueMap;
    基本上就理解了果子的想法了
    果子,你能否在你的测试用例里面加上这样的例子
    put(9,1);
    put(9,2);
    看看出来的数据。
      

  11.   

    最简单的逻辑:
    public class Demo {
    public static void main(String[] args){
    Map<String,String> map = new HashMap();
    map.put("1", "11");
    map.put("2", "11");
    map.put("3", "22");
    map.put("4", "22");
    map.put("5", "22");
    map.put("6", "33");
    map.put("7", "33");
    map.put("8", "33");

    String value = "11";
    for(String key : map.keySet()){
    if(value.equals(map.get(key)))
    System.out.println(key);
    }
    }
    }
    结果:2 1
      

  12.   

    我本来不想看的被generic吸引了。。
    拜拜楼上大牛