如果我的值"foo"和HashMap<String> ftw ftw.containsValue("foo")返回true，我该如何获得相应的密钥？我是否必须遍历hashmap？最好的方法是什么？
答案 0 :(得分：583)
如果您的数据结构在键和值之间有多对一映射，则应迭代条目并选择所有合适的键：
public static <T, E> Set<T> getKeysByValue(Map<T, E> map, E value) {
Set<T> keys = new HashSet<T>();
for (Entry<T, E> entry : map.entrySet()) {
if (Objects.equals(value, entry.getValue())) {
keys.add(entry.getKey());
}
}
return keys;
}
如果是一对一关系，您可以返回第一个匹配的密钥：
public static <T, E> T getKeyByValue(Map<T, E> map, E value) {
for (Entry<T, E> entry : map.entrySet()) {
if (Objects.equals(value, entry.getValue())) {
return entry.getKey();
}
}
return null;
}
在Java 8中：
public static <T, E> Set<T> getKeysByValue(Map<T, E> map, E value) {
return map.entrySet()
.stream()
.filter(entry -> Objects.equals(entry.getValue(), value))
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
}
此外，对于Guava用户，BiMap可能很有用。例如：
BiMap<Token, Character> tokenToChar =
ImmutableBiMap.of(Token.LEFT_BRACKET, '[', Token.LEFT_PARENTHESIS, '(');
Token token = tokenToChar.inverse().get('(');
Character c = tokenToChar.get(token);
答案 1 :(得分：203)
如果您选择使用Commons Collections library而不是标准Java Collections API，则可以轻松实现此目的。
集合库中的BidiMap接口是一个双向映射，允许您将键映射到值（如法线贴图），还可以将值映射到键，从而允许您在两个方向上执行查找。 getKey() method支持获取值的键。
但有一点需要注意，比迪映射不能将多个值映射到键，因此除非您的数据集在键和值之间具有1：1的映射，否则您无法使用bidimaps。
<强>更新
如果您想依赖Java Collections API，则必须确保在将值插入地图时键和值之间的1：1关系。这说起来容易做起来难。
一旦确定，请使用entrySet() method获取Map中的条目集（映射）。获得类型为Map.Entry的集后，请遍历这些条目，将stored value与预期值进行比较，然后获取corresponding key。
更新＃2
可以在Google Guava和重构的Commons-Collections库（后者不是Apache项目）中找到对泛型的双向地图的支持。感谢Esko指出Apache Commons Collections中缺少的通用支持。使用带有泛型的集合可以使代码更易于维护。
答案 2 :(得分：71)
public class NewClass1 {
public static void main(String[] args) {
Map<Integer, String> testMap = new HashMap<Integer, String>();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Entry<Integer, String> entry : testMap.entrySet()) {
if (entry.getValue().equals("c")) {
System.out.println(entry.getKey());
}
}
}
}
其他一些信息......可能对您有用
如果您的hashmap非常大，则上面的方法可能不太好。如果您的hashmap包含唯一值映射的唯一键，则可以再维护一个包含从Value到Key的映射的hashmap。
那就是你必须维护两个哈希映射
1. Key to value
2. Value to key
在这种情况下，您可以使用第二个hashmap来获取密钥。
答案 3 :(得分：18)
我认为你的选择是
entrySet()并找到与该值匹配的键。这是最慢的方法，因为它需要遍历整个集合，而其他两种方法不需要这样。答案 4 :(得分：18)
您可以将键，值对及其反转插入到地图结构中
map.put("theKey", "theValue");
map.put("theValue", "theKey");
使用map.get（“theValue”）将返回“theKey”。
这是一种快速而肮脏的方式，我制作了常量地图，这只适用于少数数据集：
答案 5 :(得分：14)
使用您自己的实现装饰地图
class MyMap<K,V> extends HashMap<K, V>{
Map<V,K> reverseMap = new HashMap<V,K>();
@Override
public V put(K key, V value) {
// TODO Auto-generated method stub
reverseMap.put(value, key);
return super.put(key, value);
}
public K getKey(V value){
return reverseMap.get(value);
}
}
答案 6 :(得分：11)
要查找映射到该值的所有键，请使用map.entrySet()遍历散列映射中的所有对。
答案 7 :(得分：11)
没有明确的答案，因为多个键可以映射到相同的值。如果您使用自己的代码强制执行unique-ness，最好的解决方案是创建一个使用两个Hashmaps来跟踪两个方向上的映射的类。
答案 8 :(得分：8)
我认为这是最佳解决方案，原始地址：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));
答案 9 :(得分：7)
如果您在自己的代码中构建地图，请尝试将关键字和值一起放在地图中：
public class KeyValue {
public Object key;
public Object value;
public KeyValue(Object key, Object value) { ... }
}
map.put(key, new KeyValue(key, value));
然后当你有一个值时，你也有了密钥。
答案 10 :(得分：6)
我担心你只需要迭代你的地图。最短的我能想出来：
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();
}
}
答案 11 :(得分：6)
听起来这是使用map.entrySet()迭代条目的最佳方式，因为map.containsValue()可能会这样做。
答案 12 :(得分：6)
for(int key: hm.keySet()) {
if(hm.get(key).equals(value)) {
System.out.println(key);
}
}
答案 13 :(得分：5)
针对Android开发定位API＆lt; 19，Vitalii Fedorenko一对一关系解决方案不起作用，因为Objects.equals未实现。这是一个简单的替代方案：
public <K, V> K getKeyByValue(Map<K, V> map, V value) {
for (Map.Entry<K, V> entry : map.entrySet()) {
if (value.equals(entry.getValue())) {
return entry.getKey();
}
}
return null;
}
答案 14 :(得分：5)
使用Java 8：
ftw.forEach((key, value) -> {
if (value=="foo") {
System.out.print(key);
}
});
答案 15 :(得分：3)
您可以使用以下内容：
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);
}
}
}
}
答案 16 :(得分：2)
在java8中
map.entrySet().stream().filter(entry -> entry.getValue().equals(value))
.forEach(entry -> System.out.println(entry.getKey()));
答案 17 :(得分：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;
}
答案 18 :(得分：2)
public static class SmartHashMap <T1 extends Object, T2 extends Object> {
public HashMap<T1, T2> keyValue;
public HashMap<T2, T1> valueKey;
public SmartHashMap(){
this.keyValue = new HashMap<T1, T2>();
this.valueKey = new HashMap<T2, T1>();
}
public void add(T1 key, T2 value){
this.keyValue.put(key, value);
this.valueKey.put(value, key);
}
public T2 getValue(T1 key){
return this.keyValue.get(key);
}
public T1 getKey(T2 value){
return this.valueKey.get(value);
}
}
答案 19 :(得分：2)
您可以使用以下代码使用值获取密钥..
ArrayList valuesList = new ArrayList();
Set keySet = initalMap.keySet();
ArrayList keyList = new ArrayList(keySet);
for(int i = 0 ; i < keyList.size() ; i++ ) {
valuesList.add(initalMap.get(keyList.get(i)));
}
Collections.sort(valuesList);
Map finalMap = new TreeMap();
for(int i = 0 ; i < valuesList.size() ; i++ ) {
String value = (String) valuesList.get(i);
for( int j = 0 ; j < keyList.size() ; j++ ) {
if(initalMap.get(keyList.get(j)).equals(value)) {
finalMap.put(keyList.get(j),value);
}
}
}
System.out.println("fianl map ----------------------> " + finalMap);
答案 20 :(得分：1)
从 Map 中获取给定值的键的最简单实用方法：
public static void fetchValue(Map<String, Integer> map, Integer i)
{
Stream stream = map.entrySet().stream().filter(val-> val.getValue().equals(i)).map(Map.Entry::getKey);
stream.forEach(System.out::println);
}
详细说明：
方法 fetchValue 接受映射，它的键是 String，值是 Integer。
然后我们使用 entryset().stream() 将结果转换为流。
接下来我们使用过滤器（中间操作），它为我们提供一个等于第二个参数的值。
最后，我们使用 forEach(final operation) 来打印我们的最终结果。
答案 21 :(得分：1)
虽然这并没有直接回答这个问题，但它是相关的。
这样您就不需要继续创建/迭代了。只需创建一次反向地图即可获得所需内容。
/**
* Both key and value types must define equals() and hashCode() for this to work.
* This takes into account that all keys are unique but all values may not be.
*
* @param map
* @param <K>
* @param <V>
* @return
*/
public static <K, V> Map<V, List<K>> reverseMap(Map<K,V> map) {
if(map == null) return null;
Map<V, List<K>> reverseMap = new ArrayMap<>();
for(Map.Entry<K,V> entry : map.entrySet()) {
appendValueToMapList(reverseMap, entry.getValue(), entry.getKey());
}
return reverseMap;
}
/**
* Takes into account that the list may already have values.
*
* @param map
* @param key
* @param value
* @param <K>
* @param <V>
* @return
*/
public static <K, V> Map<K, List<V>> appendValueToMapList(Map<K, List<V>> map, K key, V value) {
if(map == null || key == null || value == null) return map;
List<V> list = map.get(key);
if(list == null) {
List<V> newList = new ArrayList<>();
newList.add(value);
map.put(key, newList);
}
else {
list.add(value);
}
return map;
}
答案 22 :(得分：1)
是的，你必须循环遍历hashmap，除非你按照这些不同的答案建议的方式实现。我只是得到keySet（），迭代该集合，并保留（第一个）键来获取匹配值，而不是摆弄entrySet。如果您需要所有与该值匹配的键，显然您必须完成所有操作。
正如Jonas所说，这可能已经是containsValue方法正在做的事情，所以你可能只是一起跳过那个测试，并且每次只进行迭代（或者编译器已经消除了冗余，谁知道）
另外，相对于其他答案，如果您的反向地图看起来像
Map<Value, Set<Key>>
如果您需要该功能（将它们放在一边），您可以处理非唯一键 - >值映射。这将很好地融入人们在这里使用两张地图建议的任何解决方案。
答案 23 :(得分：1)
我的2美分。 您可以获取数组中的键，然后遍历数组。如果地图非常大，这将影响此代码块的性能，其中您首先获取数组中的键，这可能会占用一些时间然后您正在循环。否则对于较小的地图应该没问题。
String[] keys = yourMap.keySet().toArray(new String[0]);
for(int i = 0 ; i < keys.length ; i++){
//This is your key
String key = keys[i];
//This is your value
yourMap.get(key)
}
答案 24 :(得分：1)
使用薄包装：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;
}
}
答案 25 :(得分：1)
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);
}
}
答案 26 :(得分：1)
/**
* This method gets the Key for the given Value
* @param paramName
* @return
*/
private String getKeyForValueFromMap(String paramName) {
String keyForValue = null;
if(paramName!=null)) {
Set<Entry<String,String>> entrySet = myMap().entrySet();
if(entrySet!=null && entrySet.size>0) {
for(Entry<String,String> entry : entrySet) {
if(entry!=null && paramName.equalsIgnoreCase(entry.getValue())) {
keyForValue = entry.getKey();
}
}
}
}
return keyForValue;
}
答案 27 :(得分：1)
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
*/
}
答案 28 :(得分：0)
看看我的例子
Map<String, String> mapPeopleAndCountry = new HashMap<>();
mapPeopleAndCountry.put("Matis", "Lithuania");
mapPeopleAndCountry.put("Carlos", "Honduras");
mapPeopleAndCountry.put("Teboho", "Lesotho");
mapPeopleAndCountry.put("Marielos", "Honduras");
List<String> peopleInHonduras = mapPeopleAndCountry.keySet()
.stream()
.filter(r -> mapPeopleAndCountry.get(r)
.equals("Honduras"))
.stream(Collectors.toList());
// will return ["Carlos", "Marielos"]
注意：未经测试，可能包含错别字
答案 29 :(得分：0)
不使用外部库的 lambda
一个key可以处理多个值（与BidiMap不同）
public static List<String> getKeysByValue(Map<String, String> map, String value) {
List<String> list = map.keySet().stream()
.collect(groupingBy(k -> map.get(k))).get(value);
return (list == null ? Collections.emptyList() : list);
}
获取包含 List 映射 key(s)
的 value
对于 1:1 映射，返回的列表是 empty 或包含 1 value
答案 30 :(得分：0)
如果您想从价值中获取密钥，最好使用bidimap（双向地图），您可以在O（1）时间内从值获取密钥。
但是，这样做的缺点是你只能使用唯一的键集和值集。
java中有一个名为表的数据结构，它只是地图的地图，如
表格＆LT; A，B，C> == map＆lt; A，地图＆lt; B，C> ＆GT;
您可以通过查询map<B,C>获取T.row(a);，也可以通过查询map<A,C>
T.column(b);
在您的特殊情况下，将C插入为常量。
所以，它喜欢＆lt; a1，b1,1> ＆LT; a2，b2,1> ，...
所以，如果你发现通过T.row（a1）---＆gt;返回 - ＆gt;的地图获取此返回地图的密钥集。
如果您需要找到键值，则T.column（b2） - ＆gt;返回 - ＆gt;的地图获取返回地图的密钥集。
优于前一种情况：
答案 31 :(得分：0)
让该值为maxValue。
Set keySet = map.keySet();
keySet.stream().filter(x->map.get(x)==maxValue).forEach(x-> System.out.println(x));
答案 32 :(得分：0)
据我所知，当您将HashMap的键和值表示为数组时，它们不会混合在一起：
hashmap.values().toArray()
和
hashmap.keySet().toArray()
因此以下代码（自Java 8起）应该可以正常工作：
public Object getKeyByFirstValue(Object value) {
int keyNumber = Arrays.asList(hashmap.values().toArray()).indexOf(value);
return hashmap.keySet().toArray()[keyNumber];
}
但是（警告！）它的工作速度比迭代慢2-3倍。
答案 33 :(得分：0)
试试这个：
static String getKeyFromValue(LinkedHashMap<String, String> map,String value) {
for (int x=0;x<map.size();x++){
if( String.valueOf( (new ArrayList<String>(map.values())).get(x) ).equals(value))
return String.valueOf((new ArrayList<String>(map.keySet())).get(x));
}
return null;
}
答案 34 :(得分：0)
我认为 keySet（）可能很好找到映射到该值的键，并且具有比 entrySet（）更好的编码样式。
例如：
假设您有一个HashMap 地图，ArrayList res ，值，您想找到所有密钥映射到，然后将密钥存储到 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());
}
}
希望有所帮助：）
答案 35 :(得分：0)
重要的是要注意，自从这个问题以来，Apache Collections支持Generic BidiMaps。因此，在这一点上，一些最高投票的答案不再准确。
对于也支持重复值的序列化BidiMap（1对多场景），还要考虑MapDB.org。
答案 36 :(得分：-1)
Iterator<Map.Entry<String,String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String,String> entry = iterator.next();
if (entry.getValue().equals(value_you_look_for)) {
String key_you_look_for = entry.getKey();
}
}