Hashmap Java: Como obter a chave do valor?

Se eu tiver o valor "foo"e um HashMap<String> ftwpara o qual ftw.containsValue("foo")retorne true, como posso obter a chave correspondente? Preciso percorrer o hashmap? Qual o melhor jeito pra fazer isso?

Se você optar por usar a biblioteca Commons Collections em vez da API Java Collections padrão, poderá conseguir isso com facilidade.

O BidiMap interface na biblioteca Coleções é um mapa bidirecional, permitindo mapear uma chave para um valor (como mapas normais) e também mapear um valor para uma chave, permitindo realizar pesquisas nas duas direções. A obtenção de uma chave para um valor é suportada pelo método getKey () .

No entanto, existe uma ressalva: os mapas de bidi não podem ter vários valores mapeados para chaves e, portanto, a menos que seu conjunto de dados tenha mapeamentos 1: 1 entre chaves e valores, você não pode usar bidimaps.

Atualizar

Se você deseja confiar na API Java Collections, precisará garantir o relacionamento 1: 1 entre chaves e valores no momento da inserção do valor no mapa. Isto é mais fácil dizer do que fazer.

Depois de garantir isso, use o método entrySet () para obter o conjunto de entradas (mapeamentos) no Mapa. Depois de obter o conjunto cujo tipo é Map.Entry , percorra as entradas, comparando o valor armazenado com o esperado e obtenha a chave correspondente .

Atualização # 2

O suporte para mapas bidi com genéricos pode ser encontrado no Google Guava e nas bibliotecas Commons-Collections refatoradas (o último não é um projeto Apache). Agradecemos a Esko por apontar o suporte genérico ausente no Apache Commons Collections. O uso de coleções com genéricos torna o código mais sustentável.

Se sua estrutura de dados possui mapeamento muitos-para-um entre chaves e valores, você deve iterar sobre as entradas e escolher todas as chaves adequadas:

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;
}

No caso de um relacionamento individual, você pode retornar a primeira chave correspondente:

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;
}

No 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());
}

Além disso, para usuários do Guava, o BiMap pode ser útil. Por exemplo:

BiMap<Token, Character> tokenToChar = 
    ImmutableBiMap.of(Token.LEFT_BRACKET, '[', Token.LEFT_PARENTHESIS, '(');
Token token = tokenToChar.inverse().get('(');
Character c = tokenToChar.get(token);

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());
            }
        }
    }
}

Algumas informações adicionais ... Pode ser útil para você

O método acima pode não ser bom se o seu hashmap for realmente grande. Se o seu hashmap contiver uma chave exclusiva para o mapeamento de valor exclusivo, você poderá manter mais um hashmap que contenha o mapeamento de Valor para Chave.

Ou seja, você tem que manter dois hashmaps

1. Key to value

2. Value to key 

Nesse caso, você pode usar o segundo hashmap para obter a chave.

Eu acho que suas escolhas são

• Use uma implementação de mapa criada para isso, como o BiMap das coleções do Google. Observe que o BiMap das coleções do Google requer valores exclusivos, além de chaves, mas fornece alto desempenho no desempenho de ambas as direções
• Manter manualmente dois mapas - um para chave -> valor e outro mapa para valor -> chave
• Faça uma iteração entre entrySet()e para encontrar as chaves que correspondem ao valor. Esse é o método mais lento, pois requer iteração em toda a coleção, enquanto os outros dois métodos não exigem isso.

Você pode inserir o par de chave, valor e seu inverso na estrutura do mapa

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

O uso de map.get ("theValue") retornará "theKey".

É uma maneira rápida e suja de criar mapas constantes, que só funcionarão para alguns poucos conjuntos de dados selecionados:

• Contém apenas 1 a 1 pares
• O conjunto de valores é separado do conjunto de teclas (1-> 2, 2-> 3 o quebra)

Decore o mapa com sua própria implementação

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);
    }
}

Não há resposta inequívoca, porque várias chaves podem ser mapeadas para o mesmo valor. Se você estiver aplicando exclusividade com seu próprio código, a melhor solução é criar uma classe que use dois Hashmaps para rastrear os mapeamentos nas duas direções.

Para encontrar todas as chaves que são mapeadas para esse valor, itere através de todos os pares no hashmap, usando map.entrySet().

Usando o Java 8:

ftw.forEach((key, value) -> {
    if (value.equals("foo")) {
        System.out.print(key);
    }
});

Se você criar o mapa em seu próprio código, tente colocar a chave e o valor no mapa juntos:

public class KeyValue {
    public Object key;
    public Object value;
    public KeyValue(Object key, Object value) { ... }
}

map.put(key, new KeyValue(key, value));

Então, quando você tem um valor, você também tem a chave.

Eu acho que esta é a melhor solução, endereço original: 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;
          }
        }

Um uso fácil: se você colocar todos os dados no hasMap e tiver o item = "Automobile", estará procurando a chave no hashMap. essa é uma boa solução.

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

Receio que você apenas precise iterar seu mapa. O mais curto que eu consegui:

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();
    }
}

for(int key: hm.keySet()) {
    if(hm.get(key).equals(value)) {
        System.out.println(key); 
    }
}

Parece que a melhor maneira é iterar as entradas usando, map.entrySet()já que map.containsValue()provavelmente faz isso de qualquer maneira.

Para a API de segmentação de desenvolvimento para Android <19, a solução de relacionamento individual Vitalii Fedorenko não funciona porque Objects.equalsnão foi implementada. Aqui está uma alternativa simples:

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;
}

Você pode usar o abaixo:

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);
            }
        }
    }
}

Sim, você precisa percorrer o hashmap, a menos que implemente algo ao longo do que essas várias respostas sugerem. Em vez de mexer com o entrySet, eu apenas pegaria o keySet (), iteraria sobre esse conjunto e manteria a (primeira) chave que fornece seu valor correspondente. Se você precisar de todas as chaves que correspondam a esse valor, obviamente precisará fazer a coisa toda.

Como Jonas sugere, isso já pode ser o que o método containsValue está fazendo, portanto, você pode pular esse teste todos juntos e fazer a iteração sempre (ou talvez o compilador já elimine a redundância, quem sabe).

Além disso, em relação às outras respostas, se o seu mapa reverso parecer

Map<Value, Set<Key>>

você pode lidar com mapeamentos de chave-> valor não exclusivos, se precisar dessa capacidade (desmembrando-os). Isso seria incorporado em qualquer uma das soluções sugeridas pelas pessoas aqui usando dois mapas.

Você pode obter a chave usando valores usando o seguinte código.

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);

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);
    }

}

Em java8

map.entrySet().stream().filter(entry -> entry.getValue().equals(value))
    .forEach(entry -> System.out.println(entry.getKey()));

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;
}

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
     */
}

/**
 * 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;
}

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);
    }
}

Use um invólucro fino: 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;
   }
}

Meus 2 centavos. Você pode obter as chaves em uma matriz e depois percorrer a matriz. Isso afetará o desempenho desse bloco de código se o mapa for muito grande, onde você está obtendo as chaves em uma matriz primeiro, o que pode consumir algum tempo e, em seguida, você faz um loop. Caso contrário, para mapas menores, tudo ficará bem.

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)            
}

Eu acho que keySet () pode ser bom para encontrar as chaves mapeadas para o valor e ter um estilo de codificação melhor do que entrySet () .

Ex:

Suponha que você tenha um mapa HashMap , ArrayList res , um valor para o qual deseja encontrar todo o mapeamento de chaves e, em seguida, armazene as chaves nos res .

Você pode escrever o código abaixo:

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

em vez de usar entrySet () abaixo:

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

Espero que ajude :)

Embora isso não responda diretamente à pergunta, está relacionado.

Dessa forma, você não precisa continuar criando / iterando. Basta criar um mapa reverso uma vez e obter o que você precisa.

/**
 * 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;
}

É importante observar que, desde esta pergunta, o Apache Collections suporta BidiMaps genéricos . Portanto, algumas das principais respostas votadas não são mais precisas nesse ponto.

Para um BidiMap serializado que também suporta valores duplicados (cenário de 1 para muitos), considere o MapDB.org .

1. Se você deseja obter a chave do valor, é melhor usar o bidimapa (mapas bidirecionais), é possível obter a chave do valor no tempo O (1).

   Mas a desvantagem disso é que você só pode usar um conjunto de chaves e um conjunto de valores exclusivos.

2. Existe uma estrutura de dados chamada Tabela em java, que nada mais é do que mapa de mapas como

   Tabela <A, B, C> == mapa <A, mapa <B, C>>

   Aqui você pode map<B,C>consultar T.row(a);, e também map<A,C>consultarT.column(b);

No seu caso especial, insira C como uma constante.

Então, é como <a1, b1, 1> <a2, b2, 1>, ...

Portanto, se você encontrar via T.row (a1) ---> retorna o mapa de -> obtenha o conjunto de chaves deste mapa retornado.

Se você precisar encontrar o valor da chave, T.column (b2) -> retorna o mapa de -> obtém o conjunto de chaves do mapa retornado.

Vantagens em relação ao caso anterior:

1. Pode usar vários valores.
2. Mais eficiente ao usar grandes conjuntos de dados.