Java Hashmap: jak uzyskać klucz z wartości?

Jeśli twoja struktura danych ma mapowanie many-To-one pomiędzy kluczami i wartościami, powinieneś iterację nad wpisami i wybrać wszystkie odpowiednie klucze:

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

W przypadku relacji jeden do jednego , możesz zwrócić pierwszy dopasowany klucz:

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

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

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

Kilka dodatkowych informacji... Może Ci się przydać

Powyższa metoda może nie być dobra, jeśli twoja hashmapa jest naprawdę duża. Jeśli twoja hashmapa zawiera unikalny klucz do unikalnego mapowania wartości, możesz zachować jeszcze jeden hashmap zawierający mapowanie od wartości do klucza.

Czyli musisz utrzymać dwa hashmapy

1. Key to value

2. Value to key 

W takim przypadku możesz użyć drugiej hashmapy, aby uzyskać klucz.

Możesz wstawić zarówno klucz, parę wartości, jak i jej odwrotność do struktury Mapy

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

Korzystanie z mapy.get ("theValue") zwróci"theKey".

Jest to szybki i brudny sposób, że zrobiłem stałe mapy, które będą działać tylko dla wybranych kilku zbiorów danych:

• zawiera tylko 1 do 1 par
• zbiór wartości jest oddzielony od zbioru kluczy (1->2, 2->3 breaks it)

Myślę, że Twoje wybory są

• Użyj implementacji map stworzonej do tego celu, jak BiMap z kolekcji google. Należy pamiętać, że google collections BiMap wymaga unikalnych wartości, a także kluczy, ale zapewnia wysoką wydajność w obu kierunkach wydajność
• ręcznie utrzymuj dwie mapy - jedną dla klucza -> wartości, a drugą dla klucza - > wartości
• iterować przez {[0] } i znaleźć klucze, które pasują do wartości. Jest to najwolniejsza metoda, ponieważ wymaga iteracji przez całą kolekcję, podczas gdy dwie pozostałe metody tego nie wymagają.

Aby znaleźć wszystkie klucze, które odwzorowują tę wartość, przejrzyj wszystkie pary w hashmapie, używając map.entrySet().

Nie ma jednoznacznej odpowiedzi, ponieważ wiele klawiszy może odwzorować tę samą wartość. Jeśli wymuszasz unikalność za pomocą własnego kodu, najlepszym rozwiązaniem jest utworzenie klasy, która używa dwóch HashMap do śledzenia mapowań w obu kierunkach.

Udekoruj mapę własną implementacją

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

Myślę, że to najlepsze rozwiązanie, oryginalny adres: 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;
          }
        }

Łatwa obsługa: jeśli umieścisz wszystkie dane w hasMap i masz item = "Automobile" , więc szukasz jego klucza w hashMap. to dobre rozwiązanie.

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

Jeśli zbudujesz mapę w swoim własnym kodzie, spróbuj umieścić klucz i wartość na mapie razem:

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

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

Wtedy, gdy masz wartość, masz również klucz.

Obawiam się, że będziesz musiał zmienić swoją mapę. Najkrótszy, jaki mogłem wymyślić:

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

Wygląda na to, że najlepszym sposobem jest iteracja nad wpisami za pomocą map.entrySet(), ponieważ map.containsValue() prawdopodobnie i tak to robi.

Używanie Javy 8:

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

Dla android development targeting API Objects.equals nie jest zaimplementowane. Oto prosta alternatywa:

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

Możesz użyć poniższego:

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

Możesz uzyskać klucz używając wartości używając następującego kodu..

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

}

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

Tak, musisz zapętlić hashmapę, chyba że zaimplementujesz coś zgodnie z tym, co sugerują te różne odpowiedzi. Zamiast majstrować przy entrySet, chciałbym po prostu dostać keySet (), iterate nad tym zestawem, i zachować (pierwszy) klucz, który daje Ci pasującą wartość. Jeśli potrzebujesz wszystkich kluczy, które pasują do tej wartości, oczywiście musisz zrobić wszystko.

Jak sugeruje Jonas, może to być już to, co robi metoda containsValue, więc możesz po prostu pominąć to przetestuj wszystko razem i po prostu zrób iterację za każdym razem(a może kompilator już wyeliminuje redundancję, kto wie).

Również, w stosunku do innych odpowiedzi, jeśli odwrotna Mapa wygląda jak

Map<Value, Set<Key>>

Możesz poradzić sobie z niestandardowymi mapowaniami wartości key ->, jeśli potrzebujesz tej możliwości (rozplątanie ich na bok). To włączyłoby fine do każdego z rozwiązań, które ludzie sugerują tutaj za pomocą dwóch map.

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

Użyj cienkiego opakowania: 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;
   }
}

Moje 2 centy. Możesz uzyskać klucze w tablicy, a następnie zapętlić tablicę. Wpłynie to na wydajność tego bloku kodu, jeśli mapa jest dość duża, gdzie najpierw otrzymujesz klucze w tablicy, które mogą pochłonąć trochę czasu, a następnie zapętlasz. W przeciwnym razie dla mniejszych map powinno być ok.

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

Chociaż to nie odpowiada bezpośrednio na pytanie, jest związane.

W ten sposób nie musisz ciągle tworzyć / iteracji. Wystarczy raz utworzyć odwrotną mapę i uzyskać to, czego potrzebujesz.

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

W java8

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

Ważne jest, aby pamiętać, że od tego pytania, zbiory Apache obsługują Generic BidiMaps . Więc kilka z najlepszych głosowanych odpowiedzi nie są już dokładne w tym punkcie.

Dla Serializowanej Mapy BidiMap, która obsługuje również zduplikowane wartości (scenariusz 1 do wielu), rozważ również MapDB.org .

1. Jeśli chcesz uzyskać klucz z wartości, najlepiej użyć bidimap ( mapy dwukierunkowe), możesz uzyskać klucz z wartości w czasie O(1).

   Ale wadą tego jest to, że możesz używać tylko unikalnych zestawów kluczy i wartości.

2. W Javie istnieje struktura danych o nazwie Table, która jest niczym innym jak mapami typu

   Tabela == Mapa >

   Tutaj możesz uzyskać map<B,C> poprzez zapytanie T.row(a);, a także możesz uzyskać map<A,C> poprzez zapytanie T.column(b);

W Twoim szczególnym przypadku, Wstaw C jako jakąś stałą.

Więc to jak ,...

Więc, jeśli znajdziesz przez T. row (a1) - - - > zwraca mapę --> get keyset tej zwróconej mapy.

Jeśli chcesz znaleźć wartość klucza, to T. column (b2) -- > zwraca mapę -- > pobiera zestaw kluczy zwracanej mapy.

Zalety w stosunku do poprzedniego przypadku:

1. może używać wielu wartości.
2. bardziej wydajny przy użyciu duże zbiory danych.

Myślę, że keySet () może dobrze znaleźć klucze odwzorowujące wartość i mieć lepszy styl kodowania niż entrySet () .

Ex:

Załóżmy, że masz mapę HashMap , ArrayList res , A wartość chcesz znaleźć wszystkie klucze do mapowania, a następnie przechowywać klucze do res .

Możesz napisać kod poniżej:

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

Zamiast używać entrySet() poniżej:

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

Mam nadzieję, że pomoże:)