首页 文章

Java Hashmap:如何从值获取密钥?

提问于
浏览
385

如果我有 "foo" 的值, ftw.containsValue("foo") 返回 trueHashMap<String> ftw ,我该如何获得相应的密钥?我是否必须遍历hashmap?最好的方法是什么?

30 回答

  • 3

    要查找映射到该值的所有键,请使用 map.entrySet() 遍历散列映射中的所有对 .

  • 1

    听起来最好的方法是使用 map.entrySet() 迭代条目,因为 map.containsValue() 可能会这样做 .

  • 18

    使用薄包装:HMap

    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Map;
    
    public class HMap<K, V> {
    
       private final Map<K, Map<K, V>> map;
    
       public HMap() {
          map = new HashMap<K, Map<K, V>>();
       }
    
       public HMap(final int initialCapacity) {
          map = new HashMap<K, Map<K, V>>(initialCapacity);
       }
    
       public boolean containsKey(final Object key) {
          return map.containsKey(key);
       }
    
       public V get(final Object key) {
          final Map<K, V> entry = map.get(key);
          if (entry != null)
             return entry.values().iterator().next();
          return null;
       }
    
       public K getKey(final Object key) {
          final Map<K, V> entry = map.get(key);
          if (entry != null)
             return entry.keySet().iterator().next();
          return null;
       }
    
       public V put(final K key, final V value) {
          final Map<K, V> entry = map
                .put(key, Collections.singletonMap(key, value));
          if (entry != null)
             return entry.values().iterator().next();
          return null;
       }
    }
    
  • 0

    值得注意的是,自从这个问题以来,Apache Collections支持Generic BidiMaps . 因此,在这一点上,一些最高投票的答案不再准确 .

    对于也支持重复值的序列化BidiMap(1对多场景)也要考虑MapDB.org .

  • 564

    您可以使用以下内容:

    public class HashmapKeyExist {
        public static void main(String[] args) {
            HashMap<String, String> hmap = new HashMap<String, String>();
            hmap.put("1", "Bala");
            hmap.put("2", "Test");
    
            Boolean cantain = hmap.containsValue("Bala");
            if(hmap.containsKey("2") && hmap.containsValue("Test"))
            {
                System.out.println("Yes");
            }
            if(cantain == true)
            {
                System.out.println("Yes"); 
            }
    
            Set setkeys = hmap.keySet();
            Iterator it = setkeys.iterator();
    
            while(it.hasNext())
            {
                String key = (String) it.next();
                if (hmap.get(key).equals("Bala"))
                {
                    System.out.println(key);
                }
            }
        }
    }
    
  • 7

    我认为你的选择是

    • 使用为此构建的 Map 实现,例如来自google集合的BiMap . 请注意,Google集合BiMap需要无关的值以及键,但它可以在两个方向上提供高性能的性能

    • 手动维护两个映射 - 一个用于键 - >值,另一个映射用于值 - >键

    • 遍历 entrySet() 并找到与该值匹配的键 . 这是最慢的方法,因为它需要遍历整个集合,而其他两种方法不需要这样 .

  • 0

    我认为这是最佳解决方案,原始地址:Java2s

    import java.util.HashMap;
        import java.util.Map;
    
            public class Main {
    
              public static void main(String[] argv) {
                Map<String, String> map = new HashMap<String, String>();
                map.put("1","one");
                map.put("2","two");
                map.put("3","three");
                map.put("4","four");
    
                System.out.println(getKeyFromValue(map,"three"));
              }
    
    
    // hm is the map you are trying to get value from it
              public static Object getKeyFromValue(Map hm, Object value) {
                for (Object o : hm.keySet()) {
                  if (hm.get(o).equals(value)) {
                    return o;
                  }
                }
                return null;
              }
            }
    

    一个简单的用法:如果你把所有数据放在hasMap中并且你有item =“Automobile”,那么你在hashMap中看它的关键 . 这是很好的解决方案 .

    getKeyFromValue(hashMap, item);
    System.out.println("getKeyFromValue(hashMap, item): "+getKeyFromValue(hashMap, item));
    
  • 1

    我认为 keySet() 可能很好找到映射到该值的键,并且具有比 entrySet() 更好的编码风格 .

    例如:

    假设您有一个HashMap映射,ArrayList res, value ,您希望找到 all the key 映射,然后将密钥存储到res .

    您可以在下面编写代码:

    for (int key : map.keySet()) {
            if (map.get(key) == value) {
                res.add(key);
            }
        }
    

    而不是使用下面的entrySet():

    for (Map.Entry s : map.entrySet()) {
            if ((int)s.getValue() == value) {
                res.add((int)s.getKey());
            }
        }
    

    希望能帮助到你 :)

  • 6

    您可以将键,值对及其反转插入到 Map 结构中

    map.put("theKey", "theValue");
    map.put("theValue", "theKey");
    

    然后使用map.get(“theValue”)将返回“theKey” .

    这是一种快速而肮脏的方式,我制作了恒定的 Map ,这只适用于少数几个数据集:

    • 仅包含1对1对

    • 一组值与键组不相交(1-> 2,2-> 3打破它)

  • 1

    没有明确的答案,因为多个键可以映射到相同的值 . 如果您使用自己的代码强制执行唯一性,则最佳解决方案是创建一个使用两个Hashmaps来跟踪两个方向上的映射的类 .

  • 11

    是的,你必须遍历hashmap,除非你按照这些不同的答案建议的方式实现某些东西 . 我只是获取keySet(),迭代该集合,并保留(第一个)键,以获得匹配值,而不是摆弄entrySet . 如果您需要所有与该值匹配的键,显然您必须完成所有操作 .

    正如Jonas所说,这可能已经是containsValue方法正在做的事情,所以你可能只是一起跳过那个测试,并且每次只进行迭代(或者编译器已经消除了冗余,谁知道) .

    此外,相对于其他答案,如果您的反向 Map 看起来像

    Map<Value, Set<Key>>
    

    如果你需要这种能力(将它们放在一边),你可以处理非唯一的key->值映射 . 这将很好地融入人们在这里使用两张 Map 建议的任何解决方案 .

  • 2
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Set;
    
    public class ValueKeysMap<K, V> extends HashMap <K,V>{
        HashMap<V, Set<K>> ValueKeysMap = new HashMap<V, Set<K>>();
    
        @Override
        public boolean containsValue(Object value) {
            return ValueKeysMap.containsKey(value);
        }
    
        @Override
        public V put(K key, V value) {
            if (containsValue(value)) {
                Set<K> keys = ValueKeysMap.get(value);
                keys.add(key);
            } else {
                Set<K> keys = new HashSet<K>();
                keys.add(key);
                ValueKeysMap.put(value, keys);
            }
            return super.put(key, value);
        }
    
        @Override
        public V remove(Object key) {
            V value = super.remove(key);
            Set<K> keys = ValueKeysMap.get(value);
            keys.remove(key);
            if(keys.size() == 0) {
               ValueKeysMap.remove(value);
            }
            return value;
        }
    
        public Set<K> getKeys4ThisValue(V value){
            Set<K> keys = ValueKeysMap.get(value);
            return keys;
        }
    
        public boolean valueContainsThisKey(K key, V value){
            if (containsValue(value)) {
                Set<K> keys = ValueKeysMap.get(value);
                return keys.contains(key);
            }
            return false;
        }
    
        /*
         * Take care of argument constructor and other api's like putAll
         */
    }
    
  • 2
    public static String getKey(Map<String, Integer> mapref, String value) {
        String key = "";
        for (Map.Entry<String, Integer> map : mapref.entrySet()) {
            if (map.getValue().toString().equals(value)) {
                key = map.getKey();
            }
        }
        return key;
    }
    
  • 11

    我担心你只需要迭代你的 Map . 最短的我可以想出:

    Iterator<Map.Entry<String,String>> iter = map.entrySet().iterator();
    while (iter.hasNext()) {
        Map.Entry<String,String> entry = iter.next();
        if (entry.getValue().equals(value_you_look_for)) {
            String key_you_look_for = entry.getKey();
        }
    }
    
  • 5
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Set;
    
    public class M{
    public static void main(String[] args) {
    
            HashMap<String, List<String>> resultHashMap = new HashMap<String, List<String>>();
    
            Set<String> newKeyList = resultHashMap.keySet();
    
    
            for (Iterator<String> iterator = originalHashMap.keySet().iterator(); iterator.hasNext();) {
                String hashKey = (String) iterator.next();
    
                if (!newKeyList.contains(originalHashMap.get(hashKey))) {
                    List<String> loArrayList = new ArrayList<String>();
                    loArrayList.add(hashKey);
                    resultHashMap.put(originalHashMap.get(hashKey), loArrayList);
                } else {
                    List<String> loArrayList = resultHashMap.get(originalHashMap
                            .get(hashKey));
                    loArrayList.add(hashKey);
                    resultHashMap.put(originalHashMap.get(hashKey), loArrayList);
                }
            }
    
            System.out.println("Original HashMap : " + originalHashMap);
            System.out.println("Result HashMap : " + resultHashMap);
        }
    }