Obtenir des clés de HashMap en Java

J'ai un Hashmap en Java comme celui-ci:

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

Ensuite, je le remplis comme ceci:

team1.put("United", 5);

Comment puis-je obtenir les clés? Quelque chose comme: team1.getKey()pour retourner "United".

A HashMapcontient plus d'une clé. Vous pouvez utiliser keySet()pour obtenir l'ensemble de toutes les clés.

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

stockera 1avec clé "foo"et 2avec clé "bar". Pour parcourir toutes les clés:

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

imprimera "foo"et "bar".

C'est faisable, du moins en théorie, si vous connaissez l'indice:

System.out.println(team1.keySet().toArray()[0]);

keySet() renvoie un ensemble, vous convertissez donc l'ensemble en tableau.

Le problème, bien sûr, c'est qu'un ensemble ne promet pas de garder votre commande. Si vous n'avez qu'un seul élément dans votre HashMap, vous êtes bon, mais si vous en avez plus que cela, il est préférable de faire une boucle sur la carte, comme l'ont fait d'autres réponses.

Vérifie ça.

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

(À utiliser java.util.Objects.equalscar HashMap peut contenir null)

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

Vous pouvez récupérer toutes les Mapclés de en utilisant la méthode keySet(). Maintenant, si ce dont vous avez besoin est d'obtenir une clé compte tenu de sa valeur , c'est une question entièrement différente et Mapne vous aidera pas là-bas; vous auriez besoin d'une structure de données spécialisée, comme BidiMap(une carte qui permet une recherche bidirectionnelle entre la clé et les valeurs) des collections communes d'Apache - sachez également que plusieurs clés différentes peuvent être mappées à la même valeur.

Comme vous souhaitez obtenir l'argument ( United) pour lequel la valeur est donnée ( 5), vous pouvez également envisager d'utiliser une carte bidirectionnelle (par exemple fournie par Guava: http://docs.guava-libraries.googlecode.com/git/javadoc/com/google /common/collect/BiMap.html ).

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

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

Ensuite, vous pouvez rechercher n'importe quelle clé.

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

private Map<String, Integer> _map= new HashMap<String, Integer>();
Iterator<Map.Entry<String,Integer>> itr=  _map.entrySet().iterator();
                //please check 
                while(itr.hasNext())
                {
                    System.out.println("key of : "+itr.next().getKey()+" value of      Map"+itr.next().getValue());
                }

Utilisez le fonctionnement fonctionnel pour une itération plus rapide.

team1.keySet().forEach((key) -> { System.out.println(key); });

Une solution peut être, si vous connaissez la position de la clé, de convertir les clés en un tableau de chaînes et de renvoyer la valeur à la position:

public String getKey(int pos, Map map) {
    String[] keys = (String[]) map.keySet().toArray(new String[0]);

    return keys[pos];
}

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

public class MyHashMapKeys {

    public static void main(String a[]){
        HashMap<String, String> hm = new HashMap<String, String>();
        //add key-value pair to hashmap
        hm.put("first", "FIRST INSERTED");
        hm.put("second", "SECOND INSERTED");
        hm.put("third","THIRD INSERTED");
        System.out.println(hm);
        Set<String> keys = hm.keySet();
        for(String key: keys){
            System.out.println(key);
        }
    }
}

Pour obtenir des clés dans HashMap, nous avons la méthode keySet () qui est présente dans le java.util.Hashmappackage. ex:

Map<String,String> map = new Hashmap<String,String>();
map.put("key1","value1");
map.put("key2","value2");

// Now to get keys we can use keySet() on map object
Set<String> keys = map.keySet();

Maintenant, les clés auront toutes vos clés disponibles sur la carte. ex: [clé1, clé2]

Ce que je vais faire, qui est très simple, mais qui gaspille de la mémoire, c'est de mapper les valeurs avec une clé et de faire l'inverse pour mapper les clés avec une valeur faisant ceci:

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

il est important que vous utilisiez <Object, Object>pour pouvoir mapper keys:Valueet Value:Keysaimer ça

team1.put("United", 5);

team1.put(5, "United");

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

Mais si vous utilisez une méthode spécifique sur l'un des objets des paires, je serai mieux si vous créez une autre carte:

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

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

puis

team1.put("United", 5);

team1Keys.put(5, "United");

et rappelez-vous, restez simple;)

Pour obtenir la clé et sa valeur

par exemple

private Map<String, Integer> team1 = new HashMap<String, Integer>();
  team1.put("United", 5);
  team1.put("Barcelona", 6);
    for (String key:team1.keySet()){
                     System.out.println("Key:" + key +" Value:" + team1.get(key)+" Count:"+Collections.frequency(team1, key));// Get Key and value and count
                }

Imprimera: Clé: United Valeur: 5 Clé: Barcelone Valeur: 6