Comment puis-je efficacement itérer sur chaque entrée dans une Java Carte?
https://stackoverflow.com/questions/46898
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Si j'ai un objet qui implémente l' Map interface en Java et je souhaite effectuer une itération sur chaque paire qu'il contient, ce qui est le moyen le plus efficace de passer par la carte?
Sera l'ordre des éléments dépendent de l'application de la feuille que j'ai pour l'interface?
La solution
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
Autres conseils
Pour résumer les autres réponses et de les combiner avec ce que je sais, j'ai trouvé 10 façons de le faire (voir ci-dessous).Aussi, j'ai écrit quelques tests de performance (voir les résultats ci-dessous).Par exemple, si nous voulons trouver la somme de toutes les clés et les valeurs d'une carte, on peut écrire:
À l'aide de itérateur et Carte.Entrée
long i = 0; Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry<Integer, Integer> pair = it.next(); i += pair.getKey() + pair.getValue(); }À l'aide de foreach et Carte.Entrée
long i = 0; for (Map.Entry<Integer, Integer> pair : map.entrySet()) { i += pair.getKey() + pair.getValue(); }À l'aide de forEach à partir de Java 8
final long[] i = {0}; map.forEach((k, v) -> i[0] += k + v);À l'aide de jeu de clés et foreach
long i = 0; for (Integer key : map.keySet()) { i += key + map.get(key); }À l'aide de jeu de clés et itérateur
long i = 0; Iterator<Integer> itr2 = map.keySet().iterator(); while (itr2.hasNext()) { Integer key = itr2.next(); i += key + map.get(key); }À l'aide de pour et Carte.Entrée
long i = 0; for (Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); entries.hasNext(); ) { Map.Entry<Integer, Integer> entry = entries.next(); i += entry.getKey() + entry.getValue(); }À l'aide de Java 8 Flux API
final long[] i = {0}; map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());À l'aide de Java 8 Flux API parallèle
final long[] i = {0}; map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());À l'aide de IterableMap de
Apache Collectionslong i = 0; MapIterator<Integer, Integer> it = iterableMap.mapIterator(); while (it.hasNext()) { i += it.next() + it.getValue(); }À l'aide de MutableMap de Eclipse (CS) des collections
final long[] i = {0}; mutableMap.forEachKeyValue((key, value) -> { i[0] += key + value; });
Les performances des tests (mode = AverageTime, le système = Windows 8.1 64 bits, Intel i7-4790 3.60 GHz, 16 GO)
Pour la petite carte (100 éléments), score 0.308 est le meilleur
Benchmark Mode Cnt Score Error Units test3_UsingForEachAndJava8 avgt 10 0.308 ± 0.021 µs/op test10_UsingEclipseMap avgt 10 0.309 ± 0.009 µs/op test1_UsingWhileAndMapEntry avgt 10 0.380 ± 0.014 µs/op test6_UsingForAndIterator avgt 10 0.387 ± 0.016 µs/op test2_UsingForEachAndMapEntry avgt 10 0.391 ± 0.023 µs/op test7_UsingJava8StreamApi avgt 10 0.510 ± 0.014 µs/op test9_UsingApacheIterableMap avgt 10 0.524 ± 0.008 µs/op test4_UsingKeySetAndForEach avgt 10 0.816 ± 0.026 µs/op test5_UsingKeySetAndIterator avgt 10 0.863 ± 0.025 µs/op test8_UsingJava8StreamApiParallel avgt 10 5.552 ± 0.185 µs/opPour la carte avec 10000 éléments, score 37.606 est le meilleur
Benchmark Mode Cnt Score Error Units test10_UsingEclipseMap avgt 10 37.606 ± 0.790 µs/op test3_UsingForEachAndJava8 avgt 10 50.368 ± 0.887 µs/op test6_UsingForAndIterator avgt 10 50.332 ± 0.507 µs/op test2_UsingForEachAndMapEntry avgt 10 51.406 ± 1.032 µs/op test1_UsingWhileAndMapEntry avgt 10 52.538 ± 2.431 µs/op test7_UsingJava8StreamApi avgt 10 54.464 ± 0.712 µs/op test4_UsingKeySetAndForEach avgt 10 79.016 ± 25.345 µs/op test5_UsingKeySetAndIterator avgt 10 91.105 ± 10.220 µs/op test8_UsingJava8StreamApiParallel avgt 10 112.511 ± 0.365 µs/op test9_UsingApacheIterableMap avgt 10 125.714 ± 1.935 µs/opPour la carte avec 100000 éléments, score 1184.767 est le meilleur
Benchmark Mode Cnt Score Error Units test1_UsingWhileAndMapEntry avgt 10 1184.767 ± 332.968 µs/op test10_UsingEclipseMap avgt 10 1191.735 ± 304.273 µs/op test2_UsingForEachAndMapEntry avgt 10 1205.815 ± 366.043 µs/op test6_UsingForAndIterator avgt 10 1206.873 ± 367.272 µs/op test8_UsingJava8StreamApiParallel avgt 10 1485.895 ± 233.143 µs/op test5_UsingKeySetAndIterator avgt 10 1540.281 ± 357.497 µs/op test4_UsingKeySetAndForEach avgt 10 1593.342 ± 294.417 µs/op test3_UsingForEachAndJava8 avgt 10 1666.296 ± 126.443 µs/op test7_UsingJava8StreamApi avgt 10 1706.676 ± 436.867 µs/op test9_UsingApacheIterableMap avgt 10 3289.866 ± 1445.564 µs/op
Les graphes (tests de performance en fonction de la taille de la carte)
Tableau (perfomance des tests en fonction de la taille de la carte)
100 600 1100 1600 2100
test10 0.333 1.631 2.752 5.937 8.024
test3 0.309 1.971 4.147 8.147 10.473
test6 0.372 2.190 4.470 8.322 10.531
test1 0.405 2.237 4.616 8.645 10.707
test2 0.376 2.267 4.809 8.403 10.910
test7 0.473 2.448 5.668 9.790 12.125
test9 0.565 2.830 5.952 13.220 16.965
test4 0.808 5.012 8.813 13.939 17.407
test5 0.810 5.104 8.533 14.064 17.422
test8 5.173 12.499 17.351 24.671 30.403
Tous les tests sont sur GitHub.
Dans Java 8, vous pouvez le faire nettoyer et rapide à l'aide de la nouvelle lambdas caractéristiques:
Map<String,String> map = new HashMap<>();
map.put("SomeKey", "SomeValue");
map.forEach( (k,v) -> [do something with key and value] );
// such as
map.forEach( (k,v) -> System.out.println("Key: " + k + ": Value: " + v));
Le type de k et v sera déduit par le compilateur et il n'est pas nécessaire d'utiliser Map.Entry plus.
Facile comme bonjour!
Oui, l'ordre dépend de la Carte spécifique de mise en œuvre.
@ScArcher2 a le plus élégant de la syntaxe de Java 1.5.Dans la version 1.4, je voudrais faire quelque chose comme ceci:
Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Entry thisEntry = (Entry) entries.next();
Object key = thisEntry.getKey();
Object value = thisEntry.getValue();
// ...
}
Typique code pour une itération sur une carte est:
Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
String key = entry.getKey();
Thing thing = entry.getValue();
...
}
HashMap est la forme canonique de la carte de mise en œuvre et ne fait pas de garantie (ou bien qu'il ne devrait pas changer l'ordre si aucune mutation de fonctionnement sont réalisées). SortedMap sera de retour les entrées en fonction de l'ordre naturel des touches, ou un Comparator, si fourni. LinkedHashMap renvoie les entrées d'insertion ou d'accès d'ordre dépendant de la façon dont il a été construit. EnumMap renvoie les entrées dans l'ordre naturel des touches.
(Mise à jour:Je pense que ce n'est plus vrai.) Remarque, IdentityHashMap entrySet itérateur actuellement a un particulier de mise en œuvre qui renvoie les mêmes Map.Entry exemple pour chaque élément de la entrySet!Cependant, chaque fois qu'une nouvelle l'avance l'itérateur Map.Entry est mis à jour.
Exemple d'utilisation d'un itérateur et les génériques:
Iterator<Map.Entry<String, String>> entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = entries.next();
String key = entry.getKey();
String value = entry.getValue();
// ...
}
C'est une deuxième partie de la question:
Comment itérer sur les entrées d'une Carte - @ScArcher2 a répondu parfaitement.
Quel est l'ordre d'itération - si vous êtes juste en utilisant Map, alors, strictement parlant, il y a aucune des garanties de classement.Vous ne pouvez pas vraiment compter sur la commande donnée par toute mise en œuvre.Cependant, l' SortedMap interface étend Map et c'est exactement ce que vous êtes à la recherche pour les implémentations de cadeaux de donner une cohérence ordre de tri.
NavigableMap est une autre extension utile - c'est un SortedMap avec d'autres méthodes pour trouver des entrées par leur ordonna de position dans le jeu de clés.Donc, potentiellement, cela peut éliminer le besoin de l'itération, en premier lieu, vous pourriez être en mesure de trouver la entry vous après l'utilisation de la higherEntry, lowerEntry, ceilingEntry, ou floorEntry des méthodes.L' descendingMap méthode vous donne même une méthode explicite de l'inversion de la traversée de l'ordre.
Il existe plusieurs façons d'effectuer une itération sur la carte.
Voici la comparaison de leurs performances pour un ensemble commun de données stockées dans la carte par le stockage d'un million de paires clé-valeur dans la carte et va se répéter sur la carte.
1) à l'Aide de entrySet() pour chaque boucle
for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
entry.getKey();
entry.getValue();
}
50 millisecondes
2) à l'Aide de keySet() pour chaque boucle
for (String key : testMap.keySet()) {
testMap.get(key);
}
76 millisecondes
3) à l'Aide de entrySet() et itérateur
Iterator<Map.Entry<String,Integer>> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
Map.Entry<String,Integer> entry = itr1.next();
entry.getKey();
entry.getValue();
}
50 millisecondes
4) à l'Aide de keySet() et itérateur
Iterator itr2 = testMap.keySet().iterator();
while(itr2.hasNext()) {
String key = itr2.next();
testMap.get(key);
}
75 millisecondes
J'ai parlé this link.
La bonne façon de le faire est d'utiliser la accepté de répondre que c'est la plus efficace.- Je trouver le code suivant est un peu plus propre.
for (String key: map.keySet()) {
System.out.println(key + "/" + map.get(key));
}
Pour info, vous pouvez également utiliser map.keySet() et map.values() si vous êtes seulement intéressés par les clés/valeurs de la carte et pas l'autre.
Avec Eclipse Collections (anciennement GS Collections), vous devez utiliser le forEachKeyValue méthode sur l' MapIterable l'interface, qui est héritée par l'MutableMap et ImmutableMap interfaces et leur mise en œuvre.
final MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue(new Procedure2<Integer, String>()
{
public void value(Integer key, String value)
{
result.add(key + value);
}
});
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
Avec Java 8 lambda syntaxe, vous pouvez écrire le code comme suit:
MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue((key, value) -> result.add(key + value));
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
Note: Je suis un committer pour Eclipse Collections.
En théorie, le moyen le plus efficace dépend de la mise en œuvre du Map.L'officiel de la façon de le faire est d'appeler map.entrySet(), qui retourne un ensemble de Map.Entry, dont chacun contient une clé et une valeur (entry.getKey() et entry.getValue()).
Dans une singulière mise en œuvre, il pourrait faire une différence si vous utilisez map.keySet(), map.entrySet() ou quelque chose d'autre.Mais je ne peux pas penser à une raison pourquoi quelqu'un devrait écrire ça comme ça.Plus vraisemblablement, il ne fait aucune différence de performance ce que vous faites.
Et oui, l'ordre dépendra de la mise en œuvre - ainsi que (peut-être) l'ordre d'insertion et d'autres difficiles à contrôler les facteurs.
[edit] j'ai écrit valueSet() à l'origine, mais bien sûr entrySet() est en fait la réponse.
Java 8:
Vous pouvez utiliser des expressions lambda:
myMap.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
});
Pour plus d'informations, suivez cette.
Essayez-le avec Java 1.4:
for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){
Entry entry = (Entry) entries.next();
System.out.println(entry.getKey() + "/" + entry.getValue());
//...
}
Avec Java 8
map.forEach((k, v) -> System.out.println((k + ":" + v)));
Java 8
Nous avons forEach méthode qui accepte un expression lambda.Nous avons également obtenu flux Les api.Envisager une carte:
Map<String,String> sample = new HashMap<>();
sample.put("A","Apple");
sample.put("B", "Ball");
Itérer sur les touches:
sample.keySet().forEach((k) -> System.out.println(k));
Itération sur les valeurs:
sample.values().forEach((v) -> System.out.println(v));
Itérer sur les entrées (en Utilisant forEach et cours d'eau):
sample.forEach((k,v) -> System.out.println(k + ":" + v));
sample.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
System.out.println(currentKey + ":" + currentValue);
});
L'avantage avec les cours d'eau est qu'ils peuvent être parallélisée facilement dans le cas où nous voulons.Nous avons simplement besoin d'utiliser parallelStream() en lieu et place de stream() ci-dessus.
forEachOrdered vs forEach avec des cours d'eau ?
L' forEach ne pas suivre la rencontre de commande (si défini) et est intrinsèquement non-déterministe dans la nature où, comme le forEachOrdered n'.Donc forEach ne garantit pas que l'ordre est maintenu.Vérifiez également cette pour plus d'.
Lambda L'Expression De Java 8
En Java 1.8 (Java 8), c'est devenu beaucoup plus facile en utilisant forEach la méthode de l'Agrégat des opérations(Flux des opérations de) qui ressemble à des itérateurs de Itérable De l'Interface.
Il suffit de copier-coller ci-dessous la déclaration de votre code et de renommer la HashMap variable de hm pour votre table de hachage variable d'imprimer des paires clé-valeur.
HashMap<Integer,Integer> hm = new HashMap<Integer, Integer>();
/*
* Logic to put the Key,Value pair in your HashMap hm
*/
// Print the key value pair in one line.
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
// Just copy and paste above line to your code.
Ci-dessous l'exemple de code que j'ai essayé d'utiliser Expression Lambda.Ce truc est tellement cool.Faut essayer.
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
Random rand = new Random(47);
int i = 0;
while(i < 5) {
i++;
int key = rand.nextInt(20);
int value = rand.nextInt(50);
System.out.println("Inserting key: " + key + " Value: " + value);
Integer imap = hm.put(key, value);
if( imap == null) {
System.out.println("Inserted");
} else {
System.out.println("Replaced with " + imap);
}
}
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
Output:
Inserting key: 18 Value: 5
Inserted
Inserting key: 13 Value: 11
Inserted
Inserting key: 1 Value: 29
Inserted
Inserting key: 8 Value: 0
Inserted
Inserting key: 2 Value: 7
Inserted
key: 1 value:29
key: 18 value:5
key: 2 value:7
key: 8 value:0
key: 13 value:11
Aussi, on peut utiliser Spliterator pour les mêmes.
Spliterator sit = hm.entrySet().spliterator();
Mise à JOUR
Y compris des liens vers la documentation d'Oracle Docs.Pour plus d'informations sur Lambda aller à ce lien et doit lire Les Opérations D'Agrégation et pour Spliterator aller à ce lien.
Dans la Carte, on peut Itération sur keys et/ou values et/ou both (e.g., entrySet) dépend des intéressés in_ Comme:
1.) Itérer sur les keys -> keySet() de la carte:
Map<String, Object> map = ...;
for (String key : map.keySet()) {
//your Business logic...
}
2.) Itérer sur les values -> values() de la carte:
for (Object value : map.values()) {
//your Business logic...
}
3.) Itérer sur les both -> entrySet() de la carte:
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
//your Business logic...
}
En outre, il y a 3 différence façons de parcourir une table de hachage.Ils sont comme ci-dessous_
//1.
for (Map.Entry entry : hm.entrySet()) {
System.out.print("key,val: ");
System.out.println(entry.getKey() + "," + entry.getValue());
}
//2.
Iterator iter = hm.keySet().iterator();
while(iter.hasNext()) {
Integer key = (Integer)iter.next();
String val = (String)hm.get(key);
System.out.println("key,val: " + key + "," + val);
}
//3.
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Integer key = (Integer)entry.getKey();
String val = (String)entry.getValue();
System.out.println("key,val: " + key + "," + val);
}
Plus compact avec Java 8:
map.entrySet().forEach(System.out::println);
public class abcd{
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 (Integer key:testMap.keySet()) {
String value=testMap.get(key);
System.out.println(value);
}
}
}
OU
public class abcd {
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()) {
Integer key=entry.getKey();
String value=entry.getValue();
}
}
}
Si vous avez un générique de type Carte, vous pouvez utiliser:
Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry element = (Map.Entry)it.next();
LOGGER.debug("Key: " + element.getKey());
LOGGER.debug("value: " + element.getValue());
}
Vous pouvez le faire en utilisant les génériques:
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<Integer, Integer> entry = entries.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
L'Utilisation De Java 8:
map.entrySet().forEach(entry -> System.out.println(entry.getValue()));
//Functional Oprations
Map<String, String> mapString = new HashMap<>();
mapString.entrySet().stream().map((entry) -> {
String mapKey = entry.getKey();
return entry;
}).forEach((entry) -> {
String mapValue = entry.getValue();
});
//Intrator
Map<String, String> mapString = new HashMap<>();
for (Iterator<Map.Entry<String, String>> it = mapString.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, String> entry = it.next();
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
//Simple for loop
Map<String, String> mapString = new HashMap<>();
for (Map.Entry<String, String> entry : mapString.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
La commande dépendra toujours de la carte spécifique de mise en œuvre.À l'aide de Java 8, vous pouvez utiliser l'un de ces:
map.forEach((k,v) -> { System.out.println(k + ":" + v); });
Ou:
map.entrySet().forEach((e) -> {
System.out.println(e.getKey() + " : " + e.getValue());
});
Le résultat sera le même (même ordre).Le entrySet soutenu par la carte de sorte que vous obtenez le même ordre.Le second est très pratique car il vous permet d'utiliser des expressions lambda, par exemplesi vous voulez imprimer seulement Entier des objets qui sont supérieures à 5:
map.entrySet()
.stream()
.filter(e-> e.getValue() > 5)
.forEach(System.out::println);
Le code ci-dessous montre l'itération à travers LinkedHashMap et normal HashMap (exemple).Vous verrez la différence dans l'ordre:
public class HMIteration {
public static void main(String[] args) {
Map<Object, Object> linkedHashMap = new LinkedHashMap<>();
Map<Object, Object> hashMap = new HashMap<>();
for (int i=10; i>=0; i--) {
linkedHashMap.put(i, i);
hashMap.put(i, i);
}
System.out.println("LinkedHashMap (1): ");
linkedHashMap.forEach((k,v) -> { System.out.print(k + " (#="+k.hashCode() + "):" + v + ", "); });
System.out.println("\nLinkedHashMap (2): ");
linkedHashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
System.out.println("\n\nHashMap (1): ");
hashMap.forEach((k,v) -> { System.out.print(k + " (#:"+k.hashCode() + "):" + v + ", "); });
System.out.println("\nHashMap (2): ");
hashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
}
}
LinkedHashMap (1):
10 (#=10):10, 9 (#=9):9, 8 (#=8):8, 7 (#=7):7, 6 (#=6):6, 5 (#=5):5, 4 (#=4):4, 3 (#=3):3, 2 (#=2):2, 1 (#=1):1, 0 (#=0):0,
LinkedHashMap (2):
10 : 10, 9 : 9, 8 : 8, 7 : 7, 6 : 6, 5 : 5, 4 : 4, 3 : 3, 2 : 2, 1 : 1, 0 : 0,
HashMap (1):
0 (#:0):0, 1 (#:1):1, 2 (#:2):2, 3 (#:3):3, 4 (#:4):4, 5 (#:5):5, 6 (#:6):6, 7 (#:7):7, 8 (#:8):8, 9 (#:9):9, 10 (#:10):10,
HashMap (2):
0 : 0, 1 : 1, 2 : 2, 3 : 3, 4 : 4, 5 : 5, 6 : 6, 7 : 7, 8 : 8, 9 : 9, 10 : 10,
Un moyen efficace solution itérative sur une Carte est une "pour chaque" boucle à partir de Java 5 par le biais de Java 7.Ici, il est:
for (String key : phnMap.keySet()) {
System.out.println("Key: " + key + " Value: " + phnMap.get(key));
}
À partir de Java 8, vous pouvez utiliser une expression lambda pour effectuer une itération sur une Carte.C'est une amélioration de 'forEach'
phnMap.forEach((k,v) -> System.out.println("Key: " + k + " Value: " + v));
Si vous voulez écrire un conditionnel pour lambda vous pouvez l'écrire comme ceci:
phnMap.forEach((k,v)->{
System.out.println("Key: " + k + " Value: " + v);
if("abc".equals(k)){
System.out.println("Hello abc");
}
});
Oui, comme beaucoup de gens convenu que c'est la meilleure façon d'effectuer une itération sur un Map.
Mais il y a des chances pour lancer nullpointerexception si la carte est null.N'oubliez pas de mettre null .de l'enregistrement.
|
|
- - - -
|
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
}
package com.test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Test {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("ram", "ayodhya");
map.put("krishan", "mathura");
map.put("shiv", "kailash");
System.out.println("********* Keys *********");
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key);
}
System.out.println("********* Values *********");
Collection<String> values = map.values();
for (String value : values) {
System.out.println(value);
}
System.out.println("***** Keys and Values (Using for each loop) *****");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out.println("***** Keys and Values (Using while loop) *****");
Iterator<Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<String, String>) entries
.next();
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out
.println("** Keys and Values (Using java 8 using lambdas )***");
map.forEach((k, v) -> System.out
.println("Key: " + k + "\t value: " + v));
}
}
Il y a beaucoup de façons de le faire.Ci-dessous quelques étapes simples:
Supposons que vous avez une Carte comme:
Map<String, Integer> m = new HashMap<String, Integer>();
Ensuite, vous pouvez faire quelque chose comme ci-dessous pour effectuer une itération sur les éléments de la carte.
// ********** Using an iterator ****************
Iterator<Entry<String, Integer>> me = m.entrySet().iterator();
while(me.hasNext()){
Entry<String, Integer> pair = me.next();
System.out.println(pair.getKey() + ":" + pair.getValue());
}
// *********** Using foreach ************************
for(Entry<String, Integer> me : m.entrySet()){
System.out.println(me.getKey() + " : " + me.getValue());
}
// *********** Using keySet *****************************
for(String s : m.keySet()){
System.out.println(s + " : " + m.get(s));
}
// *********** Using keySet and iterator *****************
Iterator<String> me = m.keySet().iterator();
while(me.hasNext()){
String key = me.next();
System.out.println(key + " : " + m.get(key));
}
