Comment faire pour itérer efficacement sur chaque entrée dans une carte Java?

si j'ai un objet implémentant L'interface Map en Java et que je souhaite itérer chaque paire qu'il contient, Quelle est la manière la plus efficace de passer à travers la carte?

l'ordre des éléments dépendent de l'application de la feuille que j'ai pour l'interface?

2621
demandé sur Steve Chambers 2008-09-06 01:12:48
la source

30 ответов

Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet())
{
    System.out.println(entry.getKey() + "/" + entry.getValue());
}
4195
répondu ScArcher2 2016-01-26 23:37:37
la source

pour résumer les autres réponses et les combiner avec ce que je sais, j'ai trouvé 10 principales façons de le faire (voir ci-dessous). En outre, 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:

  1. utilisant iterator et Map.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();
    }
    
  2. à l'Aide de foreach et de la Carte.Entrée

    long i = 0;
    for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
        i += pair.getKey() + pair.getValue();
    }
    
  3. utilisant forEach de Java 8

    final long[] i = {0};
    map.forEach((k, v) -> i[0] += k + v);
    
  4. utilisant keySet et foreach

    long i = 0;
    for (Integer key : map.keySet()) {
        i += key + map.get(key);
    }
    
  5. utilisant keySet et itérateur

    long i = 0;
    Iterator<Integer> itr2 = map.keySet().iterator();
    while (itr2.hasNext()) {
        Integer key = itr2.next();
        i += key + map.get(key);
    }
    
  6. utilisant 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();
    }
    
  7. utilisant le Java 8 stream API

    final long[] i = {0};
    map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
    
  8. utilisant le Java 8 stream API parallel

    final long[] i = {0};
    map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());
    
  9. En utilisant IterableMap de Apache Collections

    long i = 0;
    MapIterator<Integer, Integer> it = iterableMap.mapIterator();
    while (it.hasNext()) {
        i += it.next() + it.getValue();
    }
    
  10. à l'Aide MutableMap d'Eclipse (CS) des collections

    final long[] i = {0};
    mutableMap.forEachKeyValue((key, value) -> {
        i[0] += key + value;
    });
    

Perfomance tests (mode = AverageTime, system = Windows 8.1 64-bit, Intel i7-4790 3.60 GHz, 16 GB)

  1. pour petite carte (100 éléments), partition 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/op
    
  2. pour carte avec 10000 éléments, le 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/op
    
  3. pour carte avec 100000 éléments, le 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
    

Graphiques (perfomance des tests en fonction de la taille de la carte)

Enter image description here

(tests de performance 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 essais sont effectués sur GitHub .

750
répondu Viacheslav Vedenin 2018-04-11 00:44:37
la source

en Java 8, Vous pouvez le faire propre et rapide en utilisant les nouvelles fonctionnalités lambdas:

 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.

Easy-peasy!

231
répondu Austin Powers 2016-09-07 11:33:17
la source

Oui, l'ordre dépend de la mise en œuvre spécifique du PAM.

@ScArcher2 a la syntaxe Java 1.5 plus élégante . En 1.4, je ferais 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();
  // ...
}
201
répondu pkaeding 2018-02-07 01:32:29
la source

le code typique pour itérer 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 l'implémentation de la carte canonique et ne donne aucune garantie (ou bien elle ne doit pas changer d'ordre si aucune opération de mutation n'est effectuée sur elle). SortedMap renvoie les entrées en fonction de l'ordre naturel des touches, ou un Comparator , si fourni. LinkedHashMap retournera les entrées dans l'ordre d'insertion ou l'ordre d'accès selon 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. ), IdentityHashMap entrySet itérateur actuellement a un particulier de mise en œuvre qui renvoie les mêmes Map.Entry instance pour chaque élément de la entrySet ! Cependant, chaque fois qu'un nouveau l'iterator avance le Map.Entry est mis à jour.

103
répondu Tom Hawtin - tackline 2018-02-09 04:11:36
la source

exemple d'utilisation d'iterator et de 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();
  // ...
}
91
répondu serg 2009-08-18 21:34:51
la source

C'est une question en deux parties:

comment itérer les entrées d'une carte - @ScArcher2 a répondu que parfaitement.

Quel est l'ordre d'itération - si vous utilisez simplement Map , alors à strictement parler, il y a aucune garantie de commande . Donc vous ne devriez pas vraiment compter sur l'ordre donné par n'importe quel application. Cependant, l'interface SortedMap étend Map et fournit exactement ce que vous recherchez - les implémentations donneront un ordre de tri cohérent.

NavigableMap est une autre extension utile - il s'agit d'un SortedMap avec des méthodes supplémentaires pour trouver des entrées par leur position ordonnée dans l'ensemble de clés. Donc, potentiellement, cela peut supprimer la nécessité de itérer en premier lieu - vous pourriez être en mesure de trouver le entry spécifique que vous êtes après avoir utilisé le higherEntry , lowerEntry , ceilingEntry , ou floorEntry . La méthode descendingMap vous donne même une méthode explicite de inversant l'ordre transversal .

78
répondu serg10 2017-05-23 14:47:32
la source

il y a plusieurs façons d'itérer sur la carte.

voici une comparaison de leurs performances pour un ensemble de données communes stockées dans la carte en stockant un million de paires de valeurs clés dans la carte et itérera sur la carte.

1) en utilisant entrySet() pour chaque boucle

for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
    entry.getKey();
    entry.getValue();
}

50 millisecondes

2) en utilisant keySet() pour chaque boucle

for (String key : testMap.keySet()) {
    testMap.get(key);
}

76 millisecondes

3) utilisant entrySet() et l'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) utilisant keySet() et l'itérateur

Iterator itr2 = testMap.keySet().iterator();
while(itr2.hasNext()) {
    String key = itr2.next();
    testMap.get(key);
}

75 millisecondes

j'ai renvoi this link .

63
répondu Darshan Patel 2015-07-18 18:58:26
la source

FYI, vous pouvez également utiliser map.keySet() et map.values() si vous êtes seulement intéressé par les clés/valeurs de la carte et pas l'autre.

43
répondu ckpwong 2008-09-06 02:27:52
la source

la bonne façon de procéder est d'utiliser la réponse acceptée, car elle est la plus efficace. Je trouve que le code suivant est un peu plus propre.

for (String key: map.keySet()) {
   System.out.println(key + "/" + map.get(key));
}
42
répondu Chris Dail 2011-10-17 04:16:44
la source

avec Eclipse Collections (anciennement GS Collections ), vous utiliserez la méthode forEachKeyValue sur l'interface MapIterable , qui est héritée par les interfaces MutableMap et ImmutableMap et leurs implémentations.

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 la syntaxe Java 8 lambda, 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.

23
répondu Donald Raab 2018-09-13 04:25:34
la source

essayez avec Java 1.4:

for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){

  Entry entry = (Entry) entries.next();

  System.out.println(entry.getKey() + "/" + entry.getValue());

  //...
}
20
répondu abods 2013-06-07 18:34:44
la source

en théorie, la manière la plus efficace dépendra de la mise en œuvre du PAM. La manière officielle de le faire est d'appeler map.entrySet() , qui renvoie un ensemble de Map.Entry , dont chacun contient une clé et une valeur ( entry.getKey() et entry.getValue() ).

dans une implémentation idiosyncratique, cela pourrait faire une différence que vous utilisiez map.keySet() , map.entrySet() ou autre chose. Mais je ne vois pas pourquoi quelqu'un l'écrirait comme ça. Le plus probable, c' fait aucune différence dans la performance de 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.

20
répondu Leigh Caldwell 2017-05-05 01:39:46
la source

Java 8:

vous pouvez utiliser les expressions lambda:

myMap.entrySet().stream().forEach((entry) -> {
    Object currentKey = entry.getKey();
    Object currentValue = entry.getValue();
});

pour plus d'information, suivez ce .

20
répondu George Siggouroglou 2018-02-06 06:37:46
la source

Lambda Expression Java 8

en Java 1.8 (Java 8) cela est devenu beaucoup plus facile en utilisant forEach méthode des opérations agrégées ( opérations de flux ) qui ressemble à des itérateurs de itérable Interface.

il suffit de copier coller la déclaration ci-dessous à votre code et renommer le HashMap variable de hm à votre variable HashMap pour imprimer une paire de clés.

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 est le code échantillon que j'ai essayé en utilisant Lambda Expression . Ce truc est trop 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

on peut aussi utiliser Spliterator pour le même.

Spliterator sit = hm.entrySet().spliterator();

mise à JOUR


, y compris les liens de documentation vers Oracle Docs. Pour en savoir plus sur Lambda allez à ce lien et doit lire opérations agrégées et pour Spliterator aller à ce lien .

17
répondu Nitin Mahesh 2016-03-16 18:38:05
la source

dans la carte on peut itérer plus de keys et / ou values et/ou both (e.g., entrySet) dépend de son intérêt 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...
}

de plus, il y a 3 façons différentes d'itérer à travers une HashMap. 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);
}
16
répondu Rupesh Yadav 2014-01-29 16:35:03
la source
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();
        }
    }
}
15
répondu Fathah Rehman P 2013-06-07 18:34:13
la source

si vous avez une carte générique non typée, vous pouvez utiliser:

Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}
14
répondu dmunozfer 2016-03-16 19:17:58
la source

Avec Java 8

map.forEach((k, v) -> System.out.println((k + ":" + v)));
13
répondu Taras Melnyk 2018-05-03 14:25:07
la source

plus compact avec Java 8:

map.entrySet().forEach(System.out::println);
12
répondu bluehallu 2018-04-19 15:32:20
la source
    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());    
    }
10
répondu Fadid 2016-01-14 23:58:30
la source

vous pouvez le faire en utilisant des 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());
}
8
répondu Pranoti 2016-03-16 18:54:24
la source
Iterator itr2 = testMap.keySet().iterator();
while (itr2.hasNext()) {
    String key = itr2.next();
    testMap.get(key);
}

for (String key: map.keySet()) {    
    System.out.println(key + "/" + map.get(key)); 
}

la meilleure façon est entrySet() cependant.

7
répondu Debaprasad 2014-09-24 15:37:45
la source

en Java 8 nous avons la méthode forEach qui accepte une expression lambda . Nous avons aussi stream APIs. Considérez 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 flux est qu'ils peuvent être mis en parallèle facilement au cas où nous le voulons. Nous avons simplement besoin d'utiliser parallelStream() à la place de stream() ci-dessus.

6
répondu i_am_zero 2015-09-02 04:13:29
la source
           //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();

            }
6
répondu Sajad NasiriNezhad 2016-04-13 10:47:46
la source
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));
    }
}
6
répondu Rupendra Sharma 2017-04-06 09:36:15
la source

Oui, comme beaucoup de gens ont convenu que c'est la meilleure façon d'itérer sur un Map .

mais il y a des chances de 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();
}
6
répondu ꜱᴜʀᴇꜱʜ ᴀᴛᴛᴀ 2018-02-07 01:40:17
la source

Il y a beaucoup de façons de le faire. Ci-dessous quelques étapes simples:

supposons que vous ayez une carte comme:

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

alors vous pouvez faire quelque chose comme le ci-dessous pour itérer au-dessus des éléments de 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));
}
6
répondu Utpal Kumar 2018-03-22 13:10:05
la source

Utiliser Java 8:

map.entrySet().forEach(entry -> System.out.println(entry.getValue()));
6
répondu ABHAY JOHRI 2018-04-17 22:03:40
la source

la commande dépendra toujours de l'implémentation spécifique de la carte. En utilisant Java 8, Vous pouvez utiliser l'un des deux:

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). Les entrées sont appuyées par la carte de sorte que vous obtenez le même ordre. Le second est pratique car il vous permet d'utiliser lambdas, par exemple si vous voulez seulement imprimer des objets entiers qui sont plus grands que 5:

map.entrySet()
    .stream()
    .filter(e-> e.getValue() > 5)
    .forEach(System.out::println);

Le code ci-dessous montre l'itération par LinkedHashMap et HashMap normal (exemple). Vous verrez une 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,

5
répondu Witold Kaczurba 2018-03-22 13:12:23
la source

Autres questions sur java collections dictionary iteration