Hoe kan ik efficiënt elk item in een Java-kaart herhalen?

Als ik een object heb dat de Map-interface in Java implementeert en ik wil elk paar daarin herhalen, wat is dan de meest efficiënte manier om door de kaart te gaan?

Zal de volgorde van elementen afhangen van de specifieke kaartimplementatie die ik heb voor de interface?

Antwoord 1, autoriteit 100%

Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

Op Java 10+:

for (var entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

Antwoord 2, autoriteit 26%

Om de andere antwoorden samen te vatten en te combineren met wat ik weet, heb ik 10 manieren gevonden om dit te doen (zie hieronder). Ook heb ik enkele prestatietests geschreven (zie onderstaande resultaten). Als we bijvoorbeeld de som van alle sleutels en waarden van een kaart willen vinden, kunnen we schrijven:

1. iteratoren Map.Entry

   gebruiken

   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. Gebruik foreachen Map.Entry

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

3. Gebruik forEachvan Java 8

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

4. keySeten foreach

   gebruiken

   long i = 0;
   for (Integer key : map.keySet()) {
       i += key + map.get(key);
   }
   

5. Gebruik keySeten iterator

   long i = 0;
   Iterator<Integer> itr2 = map.keySet().iterator();
   while (itr2.hasNext()) {
       Integer key = itr2.next();
       i += key + map.get(key);
   }
   

6. Gebruik foren Map.Entry

   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. De Java 8 Stream API

   gebruiken

   final long[] i = {0};
   map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
   

8. De Java 8 Stream API parallel gebruiken

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

9. IterableMapvan Apache Collections

   gebruiken

   long i = 0;
   MapIterator<Integer, Integer> it = iterableMap.mapIterator();
   while (it.hasNext()) {
       i += it.next() + it.getValue();
   }
   

10. MutableMap van Eclipse (CS) -collecties

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

Perfomance-tests (MODE = Averagetime, System = Windows & NBSP; 8.1 64-bit, Intel I7-4790 3,60 GHz, 16 & NBSP; GB)

1. voor een kleine kaart (100 elementen), score 0.308 is de beste

   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. Voor een kaart met 10000 elementen, score 37.606 is de beste

   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. Voor een kaart met 100000 elementen is de score 1184.767 de beste

   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
   

Grafieken (prestatietests afhankelijk van kaartgrootte)

Tabel (prestatietests afhankelijk van kaartgrootte)

         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

Alle tests staan op GitHub.

Antwoord 3, autoriteit 6%

In Java 8 kun je het schoon en snel doen met de nieuwe lambdas-functies:

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

Het type ken vwordt afgeleid door de compiler en het is niet meer nodig om Map.Entryte gebruiken.

p>

Gemakkelijk!

Antwoord 4, autoriteit 5%

Ja, de volgorde is afhankelijk van de specifieke implementatie van de kaart.

@ScArcher2 heeft de meer elegante Java 1.5-syntaxis. In 1.4 zou ik zoiets als dit doen:

Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
  Entry thisEntry = (Entry) entries.next();
  Object key = thisEntry.getKey();
  Object value = thisEntry.getValue();
  // ...
}

Antwoord 5, autoriteit 3%

Typische code voor het herhalen van een kaart is:

Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
    String key = entry.getKey();
    Thing thing = entry.getValue();
    ...
}

HashMapis de canonieke kaartimplementatie en biedt geen garanties (of hoewel het de volgorde niet zou moeten veranderen als er geen muterende bewerkingen op worden uitgevoerd). SortedMapretourneert items op basis van de natuurlijke volgorde van de sleutels, of een Comparator, indien aanwezig. LinkedHashMapretourneert items in invoegvolgorde of toegangsvolgorde, afhankelijk van hoe het is opgebouwd. EnumMapretourneert items in de natuurlijke volgorde van sleutels.

(Update: ik denk dat dit niet langer waar is.) Let op, IdentityHashMapentrySetiterator heeft momenteel een eigenaardige implementatie die hetzelfde teruggeeft Map.Entryinstantie voor elk item in de entrySet! Echter, elke keer dat een nieuwe iterator vordert, wordt de Map.Entrybijgewerkt.

Antwoord 6, autoriteit 2%

Voorbeeld van het gebruik van iterator en generieke geneesmiddelen:

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();
  // ...
}

Antwoord 7, autoriteit 2%

Dit is een tweedelige vraag:

De invoer van een kaart herhalen– @ScArcher2 heeft die perfect beantwoord.

Wat is de volgorde van iteratie– als je alleen Mapgebruikt, dan zijn er strikt genomen geen bestelgaranties. U moet dus niet echt vertrouwen op de volgorde die door een implementatie wordt gegeven. De SortedMapinterface breidt Mapuit en biedt precies wat u zoekt – implementaties zullen altijd een consistente sorteervolgorde geven.

NavigableMapis een andere nuttige extensie– dit is een SortedMapmet aanvullende methoden voor het vinden van items op hun geordende positie in de sleutelset. Dus mogelijk kan dit de noodzaak voor iteratie in de eerste plaats wegnemen – u kunt mogelijk de specifieke entryvinden die u zoekt na het gebruik van de higherEntry, lowerEntry, ceilingEntryof floorEntrymethoden. De descendingMapmethode geeft je zelfs een expliciete methode om de verplaatsingsvolgorde om te keren.

8

FYI, u kunt ook map.keySet()en map.values()gebruiken als u alleen geïnteresseerd bent in sleutels / waarden van de kaart en niet de andere.

9

De juiste manier om dit te doen is om het geaccepteerde antwoord te gebruiken, omdat het het meest efficiënt is. Ik vind de volgende code een beetje schoner.

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

Antwoord 10

Met Java 8kun je de kaart herhalen met forEach en lambda-expressies,

map.forEach((k, v) -> System.out.println((k + ":" + v)));

Antwoord 11

Bij Eclipse Collectionszou u de forEachKeyValue-methode gebruiken op de MapIterableinterface, die wordt overgenomen door de MutableMapen ImmutableMapinterfaces en hun implementaties.

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

Met behulp van een anonieme innerlijke klasse kun je de code als volgt schrijven:

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

Opmerking:ik ben toegewijd aan Eclipse Collections.

Antwoord 12

In theorie is de meest efficiënte manier afhankelijk van welke implementatie van de kaart. De officiële manier om dit te doen, is om map.entrySet()te bellen, die een set van Map.Entryretourneert, die elk een sleutel en een waarde bevat (entry.getKey()en entry.getValue()).

In een idiosyncratische implementatie kan het een verschil maken of u map.keySet(), map.entrySet()of iets anders gebruikt. Maar ik kan geen reden bedenken waarom iemand het zo zou schrijven. Hoogstwaarschijnlijk maakt het geen verschil om te presteren wat u doet.

en ja, de bestelling is afhankelijk van de implementatie – evenals (mogelijk) de volgorde van insertie en andere hard-controlefactoren.

[bewerken] Ik schreef valueSet()oorspronkelijk, maar natuurlijk entrySet()is eigenlijk het antwoord.

Antwoord 13

LambdaExpressie Java 8

In Java 1.8 (Java 8) is dit een stuk eenvoudiger geworden door gebruik te maken van de forEachmethode van Aggregate operations(Stream operations) die lijkt op iterators van Iterable -interface.

Kopieer de onderstaande instructie gewoon in uw code en hernoem de variabele HashMapvan hmin uw HashMap-variabele om het sleutel/waarde-paar af te drukken.

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.

Hieronder staat de voorbeeldcode die ik heb geprobeerd met Lambda Expression. Dit spul is zo cool. Moet het proberen.

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

Je kunt ook Spliteratorhiervoor gebruiken.

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

UPDATE

Inclusief documentatielinks naar Oracle Docs.
Ga voor meer informatie over Lambdanaar deze linken moet Aggregate Operationslezen en ga voor Spliterator naar deze link.

Antwoord 14

Java 8:

U kunt lambda-expressies gebruiken:

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

Volg voor meer informatie dit.

Antwoord 15

In Map kan men itereren over keysen/of valuesen/of both (e.g., entrySet)afhankelijk van iemands interesse in_ Like :

1. Herhaal door de keys -> keySet()van de kaart:

   Map<String, Object> map = ...;
    for (String key : map.keySet()) {
        //your Business logic...
    }
   

2. Herhaal door de values -> values()van de kaart:

   for (Object value : map.values()) {
        //your Business logic...
    }
   

3. Herhaal door de both -> entrySet()van de kaart:

   for (Map.Entry<String, Object> entry : map.entrySet()) {
        String key = entry.getKey();
        Object value = entry.getValue();
        //your Business logic...
    }
   

Bovendien zijn er 3 verschillende manieren om te itereren via een hashmap. Ze zijn zoals hieronder:

//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

Probeer dit met Java 1.4:

for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){
  Entry entry = (Entry) entries.next();
  System.out.println(entry.getKey() + "/" + entry.getValue());
  //...
}

17

De bestelling is altijd afhankelijk van de specifieke kaartimplementatie.
Gebruik van Java & Nbsp; 8 U kunt een van deze gebruiken:

map.forEach((k,v) -> { System.out.println(k + ":" + v); });

of:

map.entrySet().forEach((e) -> {
            System.out.println(e.getKey() + " : " + e.getValue());
        });

Het resultaat is hetzelfde (dezelfde volgorde). De ingangsinstelling ondersteund door de kaart, zodat u dezelfde bestelling krijgt. De tweede is handig omdat u kunt gebruiken Lambdas, b.v. Als u alleen wilt afdrukken alleen gehele getal-objecten die groter zijn dan 5:

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

De onderstaande code toont iteratie via LinkedHashMap en normale HashMap (voorbeeld). Je zult verschil zien in de volgorde:

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() + ", ");
        });
    }
}

Uitvoer:

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,

Antwoord 18

Meest compact met Java 8:

map.entrySet().forEach(System.out::println);

Antwoord 19

Als ik een object heb dat de kaartinterface in Java implementeert en ik wil elk paar daarin herhalen, wat is dan de meest efficiënte manier om door de kaart te gaan?

Als efficiëntie van het herhalen van de sleutels een prioriteit is voor uw app, kies dan een Map-implementatie die de sleutels in de door u gewenste volgorde houdt.

Zal de volgorde van elementen afhangen van de specifieke kaartimplementatie die ik heb voor de interface?

Ja, absoluut.

• Sommige Mapimplementaties beloven een bepaalde iteratievolgorde, andere niet.
• Verschillende implementaties van Maphandhaven een verschillende volgorde van de sleutel-waardeparen.

Zie deze tabel die ik heb gemaakt met een samenvatting van de verschillende Map-implementaties die zijn gebundeld met Java 11. Let in het bijzonder op de kolom iteratievolgorde. Klik/tik om in te zoomen.

Je kunt zien dat er vier Map-implementaties zijn die een bestelling handhaven:

• TreeMap
• ConcurrentSkipListMap
• LinkedHashMap
• EnumMap

NavigableMap-interface

Twee van die implementeren de NavigableMapinterface: TreeMap& AMP; ConcurrentSkipListMap.

De oudere SortedMapInterface wordt effectief ingediend door de nieuwere NavigableMapinterface. Maar u kunt alleen implementaties van derden vinden die de oudere interface alleen implementeren.

Natuurlijke bestelling

Als u een Mapdie zijn paren bewaarden door de” natuurlijke volgorde “van de sleutel, gebruik TreeMapof ConcurrentSkipListMap. De term “natuurlijke bestelling” betekent de klasse van de sleutels implementeert Comparable. De waarde geretourneerd door de compareTomethode wordt gebruikt voor vergelijking in sorteren.

Aangepaste bestelling

Als u een aangepaste sorteerroutine wilt opgeven voor uw sleutels die moeten worden gebruikt bij het handhaven van een gesorteerde volgorde, passeert u een Comparatorimplementatie geschikt voor de klas van uw sleutels. Gebruik egistral TreeMapof ConcurrentSkipListMap, passeren van uw Comparator.

Originele Insertion Order

Als u wilt dat de paren van uw kaart in hun oorspronkelijke volgorde worden bewaard waarin u ze in de kaart hebt ingevoegd, gebruik dan LinkedHashMap.

Enum-definitieorder

Als u een ENUM gebruikt, zoals DayOfWeekof Monthals uw sleutels, gebruik de EnumMapklasse. Niet alleen is deze klasse zeer geoptimaliseerd om heel weinig geheugen te gebruiken en erg snel te rennen, het handhaaft uw paren in de volgorde die is gedefinieerd door de ENUM. Voor DayOfWeek, bijvoorbeeld, wordt de sleutel van DayOfWeek.MONDAYvoor het eerst gevonden wanneer herhent, en de sleutel van DayOfWeek.SUNDAYZAL ZAL ZIJN .

Overige overwegingen

Overweeg bij het kiezen van een Mapimplementatie ook:

• NULL-waarden. Sommige implementaties verbieden/accepteren een NULL als sleutel en/of waarde.
• Gelijktijdigheid. Als u de kaart in verschillende threads manipuleert, moet u een implementatie gebruiken die gelijktijdigheid ondersteunt. Of verpak de kaart met Collections::synchronizedMap(minder wenselijk).

Beide overwegingen worden behandeld in de bovenstaande grafische tabel.

Antwoord 20

Als u een generieke, niet-getypte kaart heeft, kunt u het volgende gebruiken:

Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

Antwoord 21

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

OF

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

Antwoord 22

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

Antwoord 23

U kunt het doen met generieke geneesmiddelen:

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

Antwoord 24

Gebruik Java 8:

map.entrySet().forEach(entry -> System.out.println(entry.getValue()));

Antwoord 25

Een effectieve iteratieve oplossing voor een kaart is een for-lus van Java 5 tot en met Java 7. Hier is het:

for (String key : phnMap.keySet()) {
    System.out.println("Key: " + key + " Value: " + phnMap.get(key));
}

Vanaf Java 8 kunt u een lambda-expressie gebruiken om een kaart te doorlopen. Het is een verbeterde forEach

phnMap.forEach((k,v) -> System.out.println("Key: " + k + " Value: " + v));

Als je een voorwaarde voor lambda wilt schrijven, kun je dat als volgt schrijven:

phnMap.forEach((k,v)->{
    System.out.println("Key: " + k + " Value: " + v);
    if("abc".equals(k)){
        System.out.println("Hello abc");
    }
});

26

          //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();
            }

27

Er zijn veel manieren om dit te doen. Hieronder is een paar eenvoudige stappen:

Stel dat u één kaart hebt zoals:

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

Dan kunt u iets als het onderstaande doen om te herhalen over kaartelementen.

// ********** 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));
}

28

iterating a kaart is heel gemakkelijk .

for(Object key: map.keySet()){
   Object value= map.get(key);
   //Do your stuff
}

Heb je bijvoorbeeld een Map<String, int> data;

for(Object key: data.keySet()){
  int value= data.get(key);
}