Java Hashmap: Як отримати ключ від значення?

Якщо у мене є значення "foo", а HashMap<String> ftwдля якого ftw.containsValue("foo")повертається true, як я можу отримати відповідний ключ? Чи потрібно прокручувати хешмап? Який найкращий спосіб зробити це?

Якщо ви вирішите використовувати бібліотеку Commons Collections замість стандартного API Java Collections, ви можете досягти цього з легкістю.

Інтерфейс BidiMap у бібліотеці колекцій - це двонаправлена ​​карта, яка дозволяє зіставити ключ із значенням (як звичайні карти), а також зіставити значення з ключем, тим самим дозволяє виконувати пошук в обох напрямках. Отримання ключа для значення підтримується методом getKey () .

Однак є застереження, що біді-карти не можуть мати декілька значень, відображених на клавіші, і, отже, якщо у вашому наборі даних не буде зіставлення 1: 1 між ключами та значеннями, ви не можете використовувати бідимапи.

Оновлення

Якщо ви хочете покластися на API Java Collections, вам доведеться забезпечити співвідношення 1: 1 між ключами та значеннями під час вставки значення на карту. Це простіше сказати, ніж зробити.

Після того, як ви переконаєтесь у цьому, використовуйте метод entrySet () для отримання набору записів (відображень) на карті. Отримавши набір, тип якого Map.Entry , повторіть записи, порівнявши збережене значення з очікуваним, і отримайте відповідний ключ .

Оновлення №2

Підтримку біді-карт із загальною інформацією можна знайти в Google Guava та відремонтованих бібліотеках Commons-Collections (остання не є проектом Apache). Дякую Еско за те, що вказав на відсутність загальної підтримки у колекціях Apache Commons. Використання колекцій із дженериками робить більш рентабельним код.

Якщо структура даних має багато-однозначне відповідність між ключами і значеннями слід перебирати НЕ записи і вибрати все відповідні ключі:

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

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

Деякі додаткові відомості ... Можуть вам стати в нагоді

Вищеописаний метод не може бути корисним, якщо ваша хеш-карта дійсно велика. Якщо ваша хешмап містить унікальний ключ до унікального відображення значень, ви можете підтримувати ще одну хешмапу, яка містить зіставлення зі значення до ключа.

Тобто вам доведеться підтримувати два хешмапи

1. Key to value

2. Value to key 

У цьому випадку ви можете використовувати другу хешмап, щоб отримати ключ.

Я думаю, що ваш вибір є

• Використовуйте для цього реалізовану карту, як і BiMap з колекцій Google. Зауважте, що колекція Google BiMap для Google вимагає унікальних значень, а також ключів, але вона забезпечує високу продуктивність в обох напрямках
• Підтримуйте вручну дві карти - одну для ключа -> значення, а іншу для значення -> ключ
• Перейдіть через entrySet()і, щоб знайти ключі, які відповідають значенню. Це найповільніший метод, оскільки він вимагає повторення через всю колекцію, тоді як інші два методи цього не потребують.

Ви можете вставити як ключ, пару значень, так і його обернену структуру вашої карти

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

За допомогою map.get ("theValue") повернеться "theKey".

Швидкий і брудний спосіб я створив постійні карти, які працюватимуть лише для декількох наборів даних:

• Містить лише 1 - 1 пари
• Набір значень відрізняється від набору клавіш (1-> 2, 2-> 3 розбиває його)

Прикрасьте карту власною реалізацією

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

Однозначної відповіді немає, оскільки кілька клавіш можуть відображати одне значення. Якщо ви застосовуєте унікальність з власним кодом, найкращим рішенням є створення класу, який використовує два хеш-карти для відстеження відображень в обох напрямках.

Щоб знайти всі ключі, які відображають це значення, повторіть усі пари в хешмапі, використовуючи map.entrySet().

Використання Java 8:

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

Якщо ви будуєте карту за власним кодом, спробуйте скласти ключ і значення на карті разом:

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

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

Тоді, коли у вас є значення, ви також маєте ключ.

Я думаю, що це найкраще рішення, оригінальна адреса: 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));

Боюся, вам просто доведеться перетворити карту. Найкоротше, що я міг придумати:

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

Здається, найкращий спосіб перебирати записи, використовуючи, map.entrySet()оскільки це, map.containsValue()мабуть, так чи інакше.

Для API орієнтування на розробку Android <19, рішення Віталія Федоренка "один на один" не працює, оскільки 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;
}

Ви можете скористатися нижче:

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

Так, вам потрібно пройти цикл хешмапу, якщо ви не реалізуєте щось відповідно до того, що пропонують ці різні відповіді. Замість того, щоб сповзати з entrySet, я просто отримаю keySet (), повторіть цей набір і збережу (першу) клавішу, яка отримує вам відповідне значення. Якщо вам потрібні всі ключі, які відповідають цій величині, очевидно, ви повинні зробити все.

Як пропонує Джонас, це може бути вже тим, що містить метод міститьValue, тож ви можете просто пропустити цей тест все разом і просто робити ітерацію кожен раз (а може, компілятор вже усуне надмірність, хто знає).

Також стосовно інших відповідей, якщо ваша зворотна карта виглядає так

Map<Value, Set<Key>>

ви можете мати справу з унікальним відображенням значень ключів>, якщо вам потрібна ця можливість (розкручуючи їх убік). Це буде добре включати будь-яке рішення, яке люди пропонують тут, використовуючи дві карти.

Ви можете отримати ключ, використовуючи значення, використовуючи наступний код ..

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

}

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

Використовуйте тонку обгортку: 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;
   }
}

Мої 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)            
}

Я думаю, що keySet (), можливо, добре знайде зіставлення ключів зі значенням і мати кращий стиль кодування, ніж entrySet () .

Наприклад:

Припустимо, у вас є карта HashMap , res ArrayList , значення, для якого потрібно знайти всі ключові карти, а потім зберегти ключі до 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());
        }
    }

Сподіваюся, це допомагає :)

Хоча це не відповідає безпосередньо на питання, воно пов'язане.

Таким чином, вам не потрібно продовжувати створювати / повторювати. Просто створіть зворотну карту один раз і отримайте те, що вам потрібно.

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

Важливо зазначити, що з цього питання Apache Collections підтримує загальні BidiMaps . Тож деякі відповіді, проголосовані вгорі, вже не точні щодо цього питання.

Для серіалізованого BidiMap, який також підтримує повторювані значення (сценарій від 1 до багатьох), також врахуйте MapDB.org .

1. Якщо ви хочете отримати ключ від значення, найкраще використовувати bidimap (двонаправлені карти), ви можете отримати ключ від значення за O (1) час.

   Але недоліком цього є те, що ви можете використовувати лише унікальний набір клавіш та набір значень.

2. Існує структура даних під назвою Table in java, яка є не що інше, як карта подібних карт

   Таблиця <A, B, C> == карта <A, карта <B, C>>

   Тут ви можете отримати map<B,C>запит T.row(a);, а також отримати map<A,C>запитT.column(b);

У вашому спеціальному випадку вставте C як деяку константу.

Отже, це як <a1, b1, 1> <a2, b2, 1>, ...

Отже, якщо ви знайдете через T.row (a1) ---> повертає карту -> отримати набір клавіш, що повертається на цю карту.

Якщо вам потрібно знайти ключове значення, T.column (b2) -> повертає карту -> отримати набір клавіш повернутої карти.

Переваги перед попереднім випадком:

1. Може використовувати кілька значень.
2. Більш ефективно при використанні великих наборів даних.