Obtenir les clés de HashMap en Java

Un HashMap contient plus d'une touche. Vous pouvez utiliser keySet() pour obtenir l'ensemble de toutes les touches.

team1.put("foo", 1);
team1.put("bar", 2);

va stocker 1 avec les principaux "foo" et 2 avec les principaux "bar". Pour effectuer une itération sur toutes les touches:

for ( String key : team1.keySet() ) {
    System.out.println( key );
}

imprime "foo" et "bar".

Vérifier cela.

https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html

(Utiliser java.util.Objects.equals parce que la table de hachage peut contenir null)

À l'aide de JDK8+

/**
 * Find any key matching a value.
 *
 * @param value The value to be matched. Can be null.
 * @return Any key matching the value in the team.
 */
private Optional<String> getKey(Integer value){
    return team1
        .entrySet()
        .stream()
        .filter(e -> Objects.equals(e.getValue(), value))
        .map(Map.Entry::getKey)
        .findAny();
}

/**
 * Find all keys matching a value.
 *
 * @param value The value to be matched. Can be null.
 * @return all keys matching the value in the team.
 */
private List<String> getKeys(Integer value){
    return team1
        .entrySet()
        .stream()
        .filter(e -> Objects.equals(e.getValue(), value))
        .map(Map.Entry::getKey)
        .collect(Collectors.toList());
}

Plus "générique" et aussi sûr que possible

/**
 * Find any key matching the value, in the given map.
 *
 * @param mapOrNull Any map, null is considered a valid value.
 * @param value     The value to be searched.
 * @param <K>       Type of the key.
 * @param <T>       Type of the value.
 * @return An optional containing a key, if found.
 */
public static <K, T> Optional<K> getKey(Map<K, T> mapOrNull, T value) {
    return Optional.ofNullable(mapOrNull).flatMap(map -> map.entrySet()
            .stream()
            .filter(e -> Objects.equals(e.getValue(), value))
            .map(Map.Entry::getKey)
            .findAny());
}

Ou si vous êtes sur JDK7.

private String getKey(Integer value){
    for(String key : team1.keySet()){
        if(Objects.equals(team1.get(key), value)){
            return key; //return the first found
        }
    }
    return null;
}

private List<String> getKeys(Integer value){
   List<String> keys = new ArrayList<String>();
   for(String key : team1.keySet()){
        if(Objects.equals(team1.get(key), value)){
             keys.add(key);
      }
   }
   return keys;
}

Si vous avez juste besoin quelque chose de simple et de plus d'une vérification.

public String getKey(String key)
{
    if(map.containsKey(key)
    {
        return key;
    }
    return null;
}

Alors vous pouvez chercher n'importe quelle touche.

System.out.println( "Does this key exist? : " + getKey("United") );

Que vous souhaitez obtenir de l'argument (United) dont la valeur est donnée (5) vous pouvez également envisager l'utilisation bidirectionnelle de la carte (par exemple par la Goyave: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/collect/BiMap.html).

Essayer ce programme simple:

public class HashMapGetKey {

public static void main(String args[]) {

      //create hash map

       HashMap map = new HashMap();

      //populate hash map

      map.put(1, "one");
      map.put(2, "two");
      map.put(3, "three");
      map.put(4, "four");

      //get keyset value from map

Set keyset=map.keySet();

      //check key set values

      System.out.println("Key set values are: " + keyset);
   }    
}

Ce que je vais faire ce qui est très simple mais la mémoire des déchets est de mapper les valeurs avec une clé et de faire le contraire de mapper les touches avec une valeur de faire ceci:

private Map<Object, Object> team1 = new HashMap<Object, Object>();

il est important que vous utilisez <Object, Object> de sorte que vous pouvez mapper keys:Value et Value:Keys comme ce

team1.put("United", 5);

team1.put(5, "United");

Donc, si vous utilisez team1.get("United") = 5 et team1.get(5) = "United"

Mais si vous utilisez une méthode spécifique sur l'un des objets dans les paires, je vais être meilleur si vous faites une autre carte:

private Map<String, Integer> team1 = new HashMap<String, Integer>();

private Map<Integer, String> team1Keys = new HashMap<Integer, String>();

et puis

team1.put("United", 5);

team1Keys.put(5, "United");

et n'oubliez pas, restez simple 😉