Moyen efficace pour trouver si la carte contient des clés à partir d'une liste/itérable

J'ai besoin de vérifier si la carte contient des clés à partir d'une liste, et si c'est le cas alors de retour de la première valeur correspondante. L'approche naïve qui vient à l'esprit est de le faire en deux boucles imbriquées:

Map<String, String> fields = new HashMap<String, String>();
fields.put("a", "value a");
fields.put("z", "value z");
String[] candidates = "a|b|c|d".split("|");
for (String key : fields.keySet()){
    for (String candidate : candidates) {
        if (key.equals(candidate)){
            return fields.get(key);
        }
    }
}

Est-il plus agréable et plus efficace, peut-être en se basant sur la norme Java bibliothèque?

InformationsquelleAutor ccpizza | 2012-12-28

22

Sûrement quelque chose comme:
```
for (String candidate : candidates) {
     String result = fields.get(key);
     if (result != null) {
         return result;
     }
}
```
Ci-dessus n'effectue un carte recherche par clé candidate. Il évite de le séparer de test pour la présence de plus d'extraction, depuis l'extraction d'une inexistant clé de tout simplement vous donner une valeur null. Remarque (merci Slanec) qu'une valeur null pour une clé valide est indiscernable d'un non-existant clé de cette solution.

Je ne comprends pas très bien pourquoi vous êtes d'effectuer la conversion de la casse, btw.
- C'est aussi efficace qu'il le peut, mais il peut devenir difficile si null est d'une valeur autorisée dans le Map.
- Intéressant... Dois-je comprends bien que l'idée est d'utiliser map.get() une fois au lieu de map.contains() + map.get() parce que cela permettrait d'éviter une deuxième recherche? Ce qui est propre!
- retainAll est descructive.
- c'est correct. Note Slanec est l'avertissement d'incendie. les valeurs null dans la carte, bien que
- De se! Je ne m'inquiète pas nulle car les clés dans la carte sont déjà validés pour null.
- Comme une note de côté, si vous aurez jamais besoin de la null de valeurs et d'optimiser les performances (j'espère qu'après une vérification avec un profileur de), vous pouvez la vaincre par l'insertion d'un objet factice au lieu de nulls. De cette façon, vous pouvez toujours faire une seule recherche et si null est retourné, vous saurez que la clé n'était pas là. Si votre objet factice est retourné, vous serez de retour null.
- Merci, c'est bon à savoir. Encore, je ne vois pas pourquoi quelqu'un voudrait-magasin null clés dans une carte. Avez-vous eu une vraie vie de cas d'utilisation pour null clés?
- En fait, oui, une fois, je pense. Dans une application où nous n'avons pas de contrôle explicite sur la table de hachage du contenu tel qu'il était configuration de l'utilisateur, et nous avons besoin de capturer un cas où un paramètre a été accessible (mais pas changé) ou réinitialiser les paramètres par défaut. Anyway, il est DONC question pour cela.
InformationsquelleAutor Brian Agnew
23
```
for(String candidate : candidates) {
 if(fields.containsKey(candidate)) {
  return fields.get(candidate)
 }
}
```
la meilleure façon, si les valeurs null sont peut-être à la carte, et si seul le premier détecté clé est nécessaire.

InformationsquelleAutor NimChimpsky

De mon point de vue:

Map<String, String> fields = new HashMap<String, String>();
fields.put("a", "value a");
fields.put("z", "value z");
String[] candidates = "a|b|c|d".split("|");
for (String candidate : candidates) {
    if (fields.containsKey(candidate)) {
        return fields.get(candidate);
    }
}

InformationsquelleAutor Petr Janeček

Dans Java 8, vous pouvez utiliser ceci:

return candidates.stream()
            .filter(fields::containsKey)
            .findFirst()
            .map(fields::get)
            .orElse(null);

InformationsquelleAutor Klapsa2503

6

Dans Java 8, vous pouvez avoir ceci:
```
boolean exists = Arrays.stream(candidates).anyMatch(fields::containsKey);
```
Si vous voulez simplement savoir si l'un des candidats est la clé de la carte.

Si vous voulez savoir la première ou de tout vous pouvez utiliser:
```
Arrays.stream(candidates).filter(fields::containsKey).findAny();
```
ou
```
Arrays.stream(candidates).filter(fields::containsKey).findFirst();
```
Comme par @Klapsa2503 réponse ci-dessus

InformationsquelleAutor mrossini
5

Essayer
```
Set<String> keySet = new HashSet<String>(fields.keySet());    
keySet.retainAll(list);
```
donc keySet est censé avoir toutes les clés de HashMap qui sont mentionnés dans la liste
- C'est, je crois, le plus court chemin. Cependant, il est peut-être pas le plus rapide, car la boucle se termine à la première trouvée résultat, mais cela continue son travail jusqu'à la fin.
- oui cela dépend si l'OP veut obtenir toutes les clés ou tout simplement pour le premier.
InformationsquelleAutor Nikolay Kuznetsov

Essayer

    List list= Arrays.asList(1, 2, 3);
    HashMap map = new HashMap();
    map.put(1, 1);
    map.put(3, 3);
    Set set = new HashSet(map.keySet());
    set.retainAll(list);
    System.out.println(set);
    Object e = set.isEmpty() ? null : set.iterator().next();
    System.out.println(e);

sortie

[1, 3]
1

InformationsquelleAutor Evgeniy Dorofeev

Map<String, String> fields = new HashMap<String, String>();
fields.put("a", "value a");
fields.put("z", "value z");
String[] candidates = "a|b|c|d".split("|");
List<String> canList = Arrays.asList(candidates );
for (String key : fields.keySet()){

if (canList .contains(key)) {
return fields.get(key);
}

}

Remarque : canList.contient est linéaire dans le temps.

InformationsquelleAutor NPKR

1

Vous pouvez utiliser une seule boucle si vous assumez la clé de la carte sont déjà en minuscules, de la même manière, vous assumez la recherche de valeurs sont en minuscules.

InformationsquelleAutor Peter Lawrey

Vous devez vous connecter pour publier un commentaire.