Cum pot itera eficient peste fiecare intrare dintr-o hartă Java? (Programare, Java, Dicționar, Colecții, Iterație)

iMack a intrebat.

Dacă am un obiect care implementează metoda Map în Java și doresc să parcurg fiecare pereche conținută în el, care este cea mai eficientă modalitate de a parcurge harta?

Ordinea elementelor va depinde de implementarea specifică a hărții pe care o am pentru interfață?

Comentarii

    41

  • În Java 8, utilizând expresia Lambda: stackoverflow.com/a/25616206/1503859 –  > Por Nitin Mahesh.
  • Java 8: stackoverflow.com/questions/46898/… -…  > Por akhil_mittal.
45 răspunsuri
ScArcher2
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

Comentarii

    94

  • Dacă faceți asta, atunci nu va funcționa, deoarece Entry este o clasă imbricata în Map. java.sun.com/javase/6/docs/docs/api/java/util/Map.html –  > Por ScArcher2.
  • 275

  • puteți scrie importul ca „import java.util.Map.Entry;” și va funcționa. –  > Por jjujuma.
  • 56

  • @Pureferret Singurul motiv pentru care ați putea dori să utilizați un iterator este dacă trebuie să apelați la remove metoda. Dacă acesta este cazul, acest alt răspuns vă arată cum să faceți acest lucru. În caz contrar, bucla îmbunătățită, așa cum se arată în răspunsul de mai sus, este calea de urmat. –  > Por assylias.
  • 107

  • Cred că forma Map.Entry este mai clară decât importarea clasei interioare în spațiul de nume curent. –  > Por Josiah Yoder.
  • 33

  • Rețineți că puteți utiliza map.values() sau map.keySet() dacă doriți să parcurgeți în buclă doar valorile sau cheile. –  > Por dguay.
Slava Vedenin

Pentru a rezuma celelalte răspunsuri și a le combina cu ceea ce știu eu, am găsit 10 modalități principale de a face acest lucru (vezi mai jos). De asemenea, am scris câteva teste de performanță (vezi rezultatele de mai jos). De exemplu, dacă vrem să găsim suma tuturor cheilor și valorilor unei hărți, putem scrie: „Sumă de chei și valori”:

  1. Folosind iterator și Map.Entry

    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. Folosind foreach și Map.Entry

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

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

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

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

    final long[] i = {0};
    map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
    
  8. Utilizarea API Java 8 Stream API paralelă

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

    long i = 0;
    MapIterator<Integer, Integer> it = iterableMap.mapIterator();
    while (it.hasNext()) {
        i += it.next() + it.getValue();
    }
    
  10. Utilizarea MutableMap a colecțiilor Eclipse (CS)

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

Teste de performanță (mod = AverageTime, sistem = Windows 8.1 pe 64 de biți, Intel i7-4790 3,60 GHz, 16 GB)

  1. Pentru o hartă mică (100 de elemente), scorul 0,308 este cel mai bun

    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. Pentru o hartă cu 10 000 de elemente, scorul 37,606 este cel mai bun.

    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. Pentru o hartă cu 100000 de elemente, scorul 1184.767 este cel mai bun.

    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
    

Grafice (teste de performanță în funcție de dimensiunea hărții)

Tabel (teste de performanță în funcție de dimensiunea hărții)

          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

Toate testele sunt efectuate pe GitHub.

Comentarii

  • @Viacheslav : foarte frumos răspuns. Mă întrebam doar cum sunt îngreunate apis-urile Java8, în benchmark-ul tău, de capturarea lambdas… (de ex. long sum = 0; map.forEach( /* accumulate in variable sum*/); captează sum long, ceea ce poate fi mai lent decât să spunem stream.mapToInt(/*whatever*/).sum de exemplu. Bineînțeles că nu poți evita întotdeauna capturarea stării, dar aceasta poate fi o adăugare rezonabilă la bench. –  > Por GPI.
  • 23

  • Testul dvs. 8 este greșit. accesează aceeași variabilă de la fire diferite fără sincronizare. Schimbați în AtomicInteger pentru a rezolva problema. –  > Por talex.
  • 51

  • @ZhekaKozlov: uitați-vă la valorile de eroare uluitor de mari. Luați în considerare faptul că un rezultat al testului de x±e implică faptul că au existat rezultate în intervalul de la x-e la x+e, , astfel încât cel mai rapid rezultat (1184.767±332.968) este cuprins între 852 la 1518, , în timp ce al doilea cel mai lent (1706.676±436.867) se situează între 1270 și 2144, , astfel încât rezultatele încă se suprapun semnificativ. Acum uitați-vă la cel mai lent rezultat, 3289.866±1445.564, , care implică o divergență între 1844 și 4735 și știți că că aceste rezultate ale testului sunt lipsite de sens. –  > Por Holger.
  • Ce ziceți de compararea celor 3 implementări principale: HashMap, LinkedHashMap și TreeMap? –  > Por Thierry.
  • 16

  • #1 și #6 sunt exact la fel. Folosind while vs. a for buclă nu este o tehnică diferită de iterație. Și sunt surprins că au o astfel de variație între ele în testele dumneavoastră – ceea ce sugerează că testele nu sunt izolate corespunzător de factori externi care nu au legătură cu lucrurile pe care intenționați să le testați. –  > Por ErikE.
Coordonatorul

În Java 8 puteți face acest lucru curat și rapid folosind noile caracteristici 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));

Tipul de k și v va fi dedus de compilator și nu este nevoie să folosiți Map.Entry mai mult.

Ușor-ușor!

Comentarii

  • În funcție de ceea ce doriți să faceți cu o hartă, puteți utiliza, de asemenea, stream API pentru intrările returnate de către map.entrySet().stream() docs.oracle.com/javase/8/docs/api/java/java/util/stream/Stream.html –  > Por Vitalii Fedorenko.
  • Acest lucru nu va funcționa dacă doriți să faceți referire la variabile nefinale declarate în afara expresiei lambda din cadrul forEach()… –  > Por Chris.
  • @Chris Corect. Nu va funcționa dacă încercați să utilizați efectiv non-finală variabile din afara lambdei. –  > Por Coordonatorul.
pkaeding

Da, ordinea depinde de implementarea specifică a Map.

@ScArcher2 are o sintaxă Java 1.5 mai elegantă. În 1.4, aș face ceva de genul acesta:

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

Comentarii

    45

  • Prefer for-loop decât while… for(Iterator entries = myMap.entrySet().iterator(); entries.hasNext(); ) {…} Cu această sintaxă, domeniul de aplicare „entries” este redus doar la bucla for. –  > Por jai.
  • @jpredham Aveți dreptate că folosind for ca for (Entry e : myMap.entrySet) nu vă va permite să modificați colecția, dar exemplul menționat de @HanuAthena ar trebui să funcționeze, deoarece vă oferă Iterator în domeniul de aplicare. (Dacă nu cumva îmi scapă ceva…) –  > Por pkaeding.
  • IntelliJ îmi dă erori la Entry thisEntry = (Entry) entries.next();: nu recunoaște Entry. Este un pseudocod pentru altceva? –  > Por JohnK.
  • @JohnK încercați să importați java.util.Map.Entry. –  > Por pkaeding.
  • Această soluție nu va funcționa dacă aveți o cheie întreagă și o cheie String. – user5778069
Tom Hawtin – tackline

Codul tipic pentru iterarea pe o hartă este:

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

HashMap este implementarea canonică a hărții și nu oferă garanții (sau deși nu ar trebui să schimbe ordinea dacă nu se efectuează nicio operațiune de mutare asupra ei). SortedMap va returna intrări pe baza ordonării naturale a cheilor sau a unui Comparator, , dacă este furnizată. LinkedHashMap va returna intrările fie în ordinea de inserție, fie în ordinea de acces, în funcție de modul în care a fost construită. EnumMap returnează intrările în ordinea naturală a cheilor.

(Actualizare: cred că acest lucru nu mai este adevărat.) Notă, IdentityHashMap entrySet iterator are în prezent o implementare particulară care returnează același Map.Entry pentru fiecare element din lista entrySet! Cu toate acestea, de fiecare dată când un nou iterator avansează Map.Entry este actualizat.

Comentarii

  • EnumMap are, de asemenea, acest comportament ciudat, împreună cu IdentityHashMap –  > Por Premraj.
  • „LinkedHashMap va returna fie intrările în […] ordinea de acces […]” … deci accesați elementele în ordinea în care le accesați? Fie tautologic, fie ceva interesant care ar putea folosi o digresiune. 😉 –  > Por jpaugh.
  • @jpaugh Nu se pot face decât accesări directe ale elementelor. LinkedHashMap numărătoare. Cele prin iterator, , spliterator, , entrySet, , etc., nu modifică ordinea. –  > Por Tom Hawtin – tackline.
  • 1. deșidacă? 2. Ultimul paragraf ar putea beneficia de o îmbunătățire. –  > Por Peter Mortensen.
serg

Exemplu de utilizare a iteratorului și a elementelor generice:

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

Comentarii

  • Ar trebui să puneți Iterator într-o buclă for pentru a-i limita domeniul de aplicare. –  > Por Steve Kuo.
  • @SteveKuo Ce vrei să spui prin „limitarea domeniului său de aplicare”? –  > Por StudioWorks.
  • @StudioWorks for (Iterator<Map.Entry<K, V>> entries = myMap.entrySet().iterator(); entries.hasNext(); ) { Map.Entry<K, V> entry = entries.next(); }. Prin utilizarea acestei construcții limităm domeniul de aplicare al (vizibilitatea variabilei) entries la bucla for. –  > Por ComFreek.
  • @ComFreek Oh, înțeleg. Nu știam că asta contează atât de mult. –  > Por StudioWorks.
serg10

Aceasta este o întrebare în două părți:

Cum să iterăm peste intrările unei hărți? – @ScArcher2 a răspuns perfect la această întrebare.

Care este ordinea de iterație – dacă utilizați doar Map, atunci, strict vorbind, există nicio garanție de ordine. Prin urmare, nu ar trebui să vă bazați pe ordinea dată de nicio implementare. Cu toate acestea, se poate folosi SortedMap interfața extinde Map și oferă exact ceea ce căutați – implementările vor oferi întotdeauna o ordine de sortare consecventă.

NavigableMap este o altă extensie utilă – aceasta este o SortedMap cu metode suplimentare pentru găsirea intrărilor în funcție de poziția lor ordonată în setul de chei. Astfel, acest lucru ar putea elimina necesitatea de a itera în primul rând – ați putea fi capabil să găsiți anumite entry pe care îl căutați folosind metoda higherEntry, , lowerEntry, , ceilingEntry, , sau floorEntry . Site-ul descendingMap vă oferă chiar și o metodă explicită de inversarea ordinii de traversare.

Darshan Patel

Există mai multe moduri de a itera peste hartă.

Iată o comparație a performanțelor acestora pentru un set de date obișnuit stocat în hartă, prin stocarea unui milion de perechi cheie-valoare în hartă și iterarea peste hartă.

1) Folosind entrySet() în bucla for each

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

50 de milisecunde

2) Utilizarea keySet() in pentru fiecare buclă

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

76 milisecunde

3) Folosind entrySet() și iterator

Iterator<Map.Entry<String,Integer>> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
    Map.Entry<String,Integer> entry = itr1.next();
    entry.getKey();
    entry.getValue();
}

50 milisecunde

4) Utilizarea keySet() și iterator

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

75 milisecunde

Am făcut referire la this link.

Comentarii

  • Timpii de execuție sunt preluați din articol, care nu utilizează Java Microbenchmarking Harness. Prin urmare, timpii nu sunt fiabili, deoarece codul ar fi putut, de exemplu, să fie complet optimizat de compilatorul JIT. –  > Por AlexB.
Chris Dail

Modul corect de a face acest lucru este de a utiliza răspunsul acceptat, deoarece este cel mai eficient. Mi se pare că următorul cod arată un pic mai curat.

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

Comentarii

    15

  • Aceasta nu este cea mai bună abordare, este mult mai eficient să folosiți entrySet(). Findbugs va semnala acest cod (a se vedea findbugs.sourceforge.net/…) –  > Por Jeff Olson.
  • @JeffOlson meh, nu chiar. căutarea hărții este O(1), astfel încât ambele bucle se comportă în același mod. este adevărat că va fi puțin mai lent într-un micro benchmark, dar uneori fac și eu acest lucru, deoarece urăsc să scriu argumentele de tip la nesfârșit. De asemenea, este foarte probabil ca acest lucru să nu fie niciodată un blocaj de performanță, așa că, dacă face codul mai ușor de citit, nu ezitați. –  > Por kritzikratzi.
  • mai multe detalii: O(1) = 2*O(1) este practic definiția notației big O. Aveți dreptate în sensul că se execută puțin mai lent, dar din punct de vedere al complexității sunt la fel. –  > Por kritzikratzi.
  • prin coliziune sau nu am vrut să spun că nu contează dacă ai câteva coliziuni, evident că e o altă poveste dacă ai doar coliziuni. deci ești destul de meschin, dar da, ceea ce spui este adevărat. –  > Por kritzikratzi.
  • @Jeff Olson: comentariile conform cărora complexitatea „Big O” nu se schimbă, când există doar un factor constant, sunt corecte. Totuși, pentru mine contează dacă o operațiune durează o oră sau două ore. Mai important, trebuie subliniat faptul că factorul este nu 2, , deoarece iterarea peste un entrySet() nu suportă deloc o consultare; este doar o parcurgere liniară a tuturor intrărilor. În schimb, iterarea peste keySet() și efectuarea unei căutări pentru fiecare cheie poartă una căutare pe cheie, deci vorbim de zero căutări față de o căutare pe cheie. n căutări aici, n fiind dimensiunea lui Map. Deci, factorul este mult peste 2… –  > Por Holger.
ckpwong

FYI, puteți utiliza și map.keySet() și map.values() dacă vă interesează doar cheile/valorile hărții și nu celelalte.

Taras Melnyk

Cu Java 8, , puteți itera harta folosind forEach și expresia lambda,

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

Donald Raab

Cu Eclipse Collections, , veți utiliza forEachKeyValue pe MapIterable care este moștenită de către MutableMap și ImmutableMap și de implementările acestora.

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

Utilizând o clasă interioară anonimă, puteți scrie codul după cum urmează:

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

Notă: Sunt un comitetor pentru Eclipse Collections.

Leigh Caldwell

În teorie, cea mai eficientă modalitate va depinde de care implementare a Map. Modul oficial de a face acest lucru este de a apela map.entrySet(), , care returnează un set de Map.Entry, , fiecare dintre acestea conținând o cheie și o valoare (entry.getKey() și entry.getValue()).

Într-o implementare idiosincratică, ar putea face o oarecare diferență dacă utilizați map.keySet(), , map.entrySet() sau altceva. Dar nu mă pot gândi la un motiv pentru care cineva ar scrie așa. Cel mai probabil, nu are nicio importanță pentru performanță ceea ce faceți.

Și da, ordinea va depinde de implementare – precum și (posibil) de ordinea de inserție și de alți factori greu de controlat.

[modifică] Am scris valueSet() inițial, dar desigur entrySet() este de fapt răspunsul.

akhil_mittal

Java 8

Avem forEach care acceptă o metodă expresie lambda. De asemenea, avem flux API-uri. Luați în considerare o hartă:

Map<String,String> sample = new HashMap<>();
sample.put("A","Apple");
sample.put("B", "Ball");

Iterați peste chei:

sample.keySet().forEach((k) -> System.out.println(k));

Iterați peste valori:

sample.values().forEach((v) -> System.out.println(v));

Iterați peste intrări (utilizând forEach și Streams):

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

Avantajul fluxurilor este că pot fi paralelizate cu ușurință în cazul în care dorim acest lucru. Trebuie pur și simplu să folosim parallelStream() în loc de stream() de mai sus.

forEachOrdered vs forEach cu fluxuri ? forEach nu urmează ordinea de întâlnire (dacă este definită) și este în mod inerent nedeterminist în natură, în timp ce forEachOrdered o face. Deci forEach nu garantează că ordinea va fi respectată. Pentru mai multe informații, consultați și acest link.

Nitin Mahesh

Lambda Expresie Java 8

În Java 1.8 (Java 8) acest lucru a devenit mult mai ușor prin utilizarea forEach din operațiunile agregate(Operațiuni de flux), care seamănă cu iteratorii din Iterable Interfață.

Trebuie doar să copiați și să lipiți declarația de mai jos în codul dvs. și să redenumiți metoda HashMap din hm în variabila HashMap pentru a tipări perechea cheie-valoare.

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.

Mai jos este exemplul de cod pe care am încercat să-l folosesc Expresia Lambda. Acest lucru este atât de tare. Trebuie să încercați.

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

De asemenea, se poate utiliza Spliterator pentru același lucru.

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

UPDATE


Inclusiv linkuri de documentare către Oracle Docs.For mai multe despre Lambda mergeți la acest link link și trebuie să citiți Operațiuni agregate iar pentru Spliterator, accesați acest link link.

George Siggouroglou

Java 8:

Puteți utiliza expresii lambda:

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

Pentru mai multe informații, urmați acest.

Comentarii

  • @injecteer: Se pare că motivul expresiilor lambda –  > Por humblerookie.
  • Nu aveți nevoie de un flux dacă doriți doar să iterați peste o hartă. myMap.forEach( (currentKey,currentValue) -> /* action */ ); este mult mai concisă. –  > Por Holger.
abods

Încercați acest lucru cu Java 1.4:

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

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

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

  //...
}

Rupesh Yadav

În Map se poate Itera peste keys și/sau values și/sau both (e.g., entrySet) depinde de ceea ce ne interesează_ Cum ar fi:

  1. Iterați prin keys -> keySet() din hartă:

     Map<String, Object> map = ...;
    
     for (String key : map.keySet()) {
         //your Business logic...
     }
    
  2. Iterați prin values -> values() din hartă:

     for (Object value : map.values()) {
         //your Business logic...
     }
    
  3. Iterați prin both -> entrySet() de pe hartă:

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

În plus, există 3 moduri diferite de a itera printr-un HashMap. Acestea sunt cele de mai jos:

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

bluehallu

Cel mai compact cu Java 8:

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

Witold Kaczurba

Ordinea va depinde întotdeauna de implementarea specifică a hărții. utilizând Java 8 puteți folosi oricare dintre acestea:

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

Sau:

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

Rezultatul va fi același (aceeași ordine). EntrySet susținut de hartă, astfel încât veți obține aceeași ordine. Cea de-a doua este utilă deoarece vă permite să utilizați lambdas, de exemplu, dacă doriți să imprimați numai obiectele Integer care sunt mai mari de 5:

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

Codul de mai jos arată iterația prin LinkedHashMap și HashMap normal (exemplu). Veți vedea diferența în ceea ce privește ordinea:

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("
LinkedHashMap (2): ");

        linkedHashMap.entrySet().forEach((e) -> {
            System.out.print(e.getKey() + " : " + e.getValue() + ", ");
        });


        System.out.println("

HashMap (1): ");
        hashMap.forEach((k,v) -> { System.out.print(k + " (#:"+k.hashCode() + "):" + v + ", "); });

        System.out.println("
HashMap (2): ");

        hashMap.entrySet().forEach((e) -> {
            System.out.print(e.getKey() + " : " + e.getValue() + ", ");
        });
    }
}

Ieșire:

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,

dmunozfer

Dacă aveți o hartă generică netipată, puteți utiliza:

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

Fathah Rehman P
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);
        }
    }
}

SAU

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

Basil Bourque

Dacă am un obiect care implementează interfața Map în Java și doresc să iteratez peste fiecare pereche conținută în el, care este cel mai eficient mod de a parcurge harta?

Dacă eficiența parcurgerii în buclă a cheilor este o prioritate pentru aplicația dvs. Map implementare care păstrează cheile în ordinea dorită.

Ordinea elementelor va depinde de implementarea specifică a hărții pe care o am pentru interfață?

Da, absolut.

  • Unele Map implementări promit o anumită ordine de iterație, altele nu.
  • Diferite implementări ale Map păstrează o ordine diferită a perechilor cheie-valoare.

Consultați acest tabel pe care l-am creat și care rezumă diferitele Map implementări incluse în Java 11. În special, observați că ordinea de iterație coloană. Faceți clic/tingeți pentru a mări imaginea.

Puteți vedea că există patru Map implementări care mențin o ordine:

  • TreeMap
  • ConcurrentSkipListMap
  • LinkedHashMap
  • EnumMap

NavigableMap interfața

Două dintre acestea implementează NavigableMap interfața: TreeMap & ConcurrentSkipListMap.

Cele mai vechi SortedMap este efectiv înlocuită de cea mai nouă interfață NavigableMap mai nouă. Cu toate acestea, este posibil să găsiți implementări ale unor terțe părți care să implementeze doar interfața mai veche.

Ordinea naturală

Dacă doriți o Map care își păstrează perechile aranjate în funcție de „ordinea naturală” a cheii, utilizați TreeMap sau ConcurrentSkipListMap. Termenul „ordine naturală” înseamnă că clasa de chei implementează Comparable. Valoarea returnată de către compareTo este utilizată pentru comparație în sortare.

Ordine personalizată

Dacă doriți să specificați o rutină de sortare personalizată pentru cheile dvs. pentru a fi utilizată în menținerea unei ordini de sortare, treceți o metodă Comparator corespunzătoare clasei cheilor dumneavoastră. Utilizați fie TreeMap fie ConcurrentSkipListMap, , trecând Comparator.

Ordinea de inserție originală

Dacă doriți ca perechile din hartă să fie păstrate în ordinea originală în care le-ați inserat în hartă, utilizați LinkedHashMap.

Ordinea de definire a enumerațiilor

Dacă utilizați un enum, cum ar fi DayOfWeek sau Month ca chei, utilizați EnumMap class. Nu numai că această clasă este foarte mare optimizată pentru a utiliza foarte puțină memorie și pentru a rula foarte rapid, dar menține perechile în ordinea definită de enum. Pentru DayOfWeek, de exemplu, cheia din DayOfWeek.MONDAY va fi găsită prima dată atunci când este iterată, iar cheia din DayOfWeek.SUNDAY va fi ultima.

Alte considerații

La alegerea unui Map implementare, luați în considerare și următoarele aspecte:

  • NULL-uri. Unele implementări interzic/acceptă un NULL ca cheie și/sau valoare.
  • Concurența. Dacă manipulați harta pe mai multe fire de execuție, trebuie să folosiți o implementare care acceptă concurența. Sau înfășurați harta cu Collections::synchronizedMap (mai puțin preferabil).

Ambele considerații sunt acoperite în tabelul grafic de mai sus.

Comentarii

  • Comentariu întârziat la un răspuns care este, de asemenea, târziu la petrecere (dar foarte informativ). +1 de la mine pentru că am menționat EnumMap, , deoarece este prima dată când aud de ea. Probabil că sunt multe cazuri în care acest lucru ar putea fi util. –  > Por user991710.
Fadid
    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());    
    }

Pranoti

Puteți face acest lucru folosind generice:

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

ABHAY JOHRI

Utilizați Java 8:

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

anandchaugule

O soluție iterativă eficientă asupra unei hărți este un for buclă din Java 5 până în Java 7. Iată-l aici:

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

Din Java 8 puteți folosi o expresie lambda pentru a itera peste o Mapă. Este o metodă îmbunătățită forEach

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

Dacă doriți să scrieți o condiționalitate pentru lambda, o puteți scrie astfel:

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

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

            }

Suresh Atta

Da, așa cum mulți oameni au fost de acord, acesta este cel mai bun mod de a itera peste o Map.

Dar există șanse de a arunca nullpointerexception dacă harta este null. Nu uitați să puneți null .check in.

                                                 |
                                                 |
                                         - - - -
                                       |
                                       |
for (Map.Entry<String, Object> entry : map.entrySet()) {
    String key = entry.getKey();
    Object value = entry.getValue();
}

Utpal Kumar

Există o mulțime de moduri de a face acest lucru. Mai jos sunt câțiva pași simpli:

Să presupunem că aveți o hartă de tipul:

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

Apoi puteți face ceva de genul celor de mai jos pentru a itera peste elementele hărții.

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

shivampip

Iterarea unui hartă este foarte ușoară.

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

De exemplu, dacă aveți un element Map<String, int> data;

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

Comentarii

  • Ei bine, acest lucru este inutil de lent, deoarece mai întâi obțineți cheile și apoi intrările. Alternativă: Obțineți seturile de intrări și apoi, pentru fiecare set de intrări, cheia și valoarea –  > Por michaeak.
Rupendra Sharma
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));
    }
}

Domnul Polywhirl

Iată o metodă generică sigură din punct de vedere al tipului, care poate fi apelată pentru a arunca orice fișier dat Map.

import java.util.Iterator;
import java.util.Map;

public class MapUtils {
    static interface ItemCallback<K, V> {
        void handler(K key, V value, Map<K, V> map);
    }

    public static <K, V> void forEach(Map<K, V> map, ItemCallback<K, V> callback) {
        Iterator<Map.Entry<K, V>> it = map.entrySet().iterator();

        while (it.hasNext()) {
            Map.Entry<K, V> entry = it.next();

            callback.handler(entry.getKey(), entry.getValue(), map);
        }
    }

    public static <K, V> void printMap(Map<K, V> map) {
        forEach(map, new ItemCallback<K, V>() {
            @Override
            public void handler(K key, V value, Map<K, V> map) {
                System.out.println(key + " = " + value);
            }
        });
    }
}

Exemplu

Iată un exemplu de utilizare a acestei metode. Observați că tipul de Map este dedus de metodă.

import java.util.*;

public class MapPrinter {
    public static void main(String[] args) {
        List<Map<?, ?>> maps = new ArrayList<Map<?, ?>>() {
            private static final long serialVersionUID = 1L;
            {
                add(new LinkedHashMap<String, Integer>() {
                    private static final long serialVersionUID = 1L;
                    {
                        put("One", 0);
                        put("Two", 1);
                        put("Three", 3);
                    }
                });

                add(new LinkedHashMap<String, Object>() {
                    private static final long serialVersionUID = 1L;
                    {
                        put("Object", new Object());
                        put("Integer", new Integer(0));
                        put("Double", new Double(0.0));
                    }
                });
            }
        };

        for (Map<?, ?> map : maps) {
            MapUtils.printMap(map);
            System.out.println();
        }
    }
}

Ieșire

One = 0
Two = 1
Three = 3

Object = [email protected]
Integer = 0
Double = 0.0

Ali Akram

Map.forEach

Ce ziceți de simpla utilizare a Map::forEach în care atât cheia, cât și valoarea sunt trecute la metoda BiConsumer?

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

Comentarii

  • Acest lucru a fost abordat în răspunsul dat de Lova Chittumuri. De asemenea, a fost abordat ca punctul nr. 3 în Răspunsul foarte votat de Viacheslav Vedenin. –  > Por Basil Bourque.
  • Dar este disponibil doar în eticheta API 24 –  > Por Mahbubur Rahman Khan.
tomaj

În cazul în care motivul dvs. pentru iterația prin intermediul Map, este de a efectua o operație asupra valorii și de a scrie pe un fișier rezultat. Map. Vă recomand să utilizați transform-din Google Guava Maps din clasa Google Guava.

import com.google.common.collect.Maps;

După ce ați adăugat Maps la importurile dvs., puteți utiliza Maps.transformValues și Maps.transformEntries pe hărțile dvs., astfel:

public void transformMap(){
    Map<String, Integer> map = new HashMap<>();
    map.put("a", 2);
    map.put("b", 4);

    Map<String, Integer> result = Maps.transformValues(map, num -> num * 2);
    result.forEach((key, val) -> print(key, Integer.toString(val)));
    // key=a,value=4
    // key=b,value=8

    Map<String, String> result2 = Maps.transformEntries(map, (key, value) -> value + "[" + key + "]");
    result2.forEach(this::print);
    // key=a,value=2[a]
    // key=b,value=4[b]
}

private void print(String key, String val){
    System.out.println("key=" + key + ",value=" + val);
}

user1098063

Mie îmi place să concatuiesc un contor, apoi să salvez valoarea finală a contorului;

int counter = 0;
HashMap<String, String> m = new HashMap<String, String>();
for(int i = 0;i<items.length;i++)
{
m.put("firstname"+i, items.get(i).getFirstName());
counter = i;
}

m.put("recordCount",String.valueOf(counter));

Apoi, atunci când doriți să recuperați:

int recordCount = Integer.parseInf(m.get("recordCount"));
for(int i =0 ;i<recordCount;i++)
{
System.out.println("First Name :" + m.get("firstname"+i));
}

Lova Chittumuri

Folosind Java 7

Map<String,String> sampleMap = new HashMap<>();
for (sampleMap.Entry<String,String> entry : sampleMap.entrySet()) {
    String key = entry.getKey();
    String value = entry.getValue();

    /* your Code as per the Business Justification  */

}

Folosind Java 8

Map<String,String> sampleMap = new HashMap<>();

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

Younes EO

Începând cu Java 10, puteți utiliza inferența variabilelor locale (alias „var”) pentru a face mai puțin umflate multe dintre răspunsurile deja disponibile. De exemplu:

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

J.B.Vala

Există mai multe moduri de a itera o hartă. Vă rugăm să consultați următorul cod.

Atunci când iterați o hartă folosind interfața iterator trebuie să mergeți cu Entry<K,V> sau entrySet().

Acesta arată în felul următor:

    import java.util.*;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;

    public class IteratMapDemo{

        public static void main(String arg[]){
            Map<String, String> mapOne = new HashMap<String, String>();
            mapOne.put("1", "January");
            mapOne.put("2", "February");
            mapOne.put("3", "March");
            mapOne.put("4", "April");
            mapOne.put("5", "May");
            mapOne.put("6", "June");
            mapOne.put("7", "July");
            mapOne.put("8", "August");
            mapOne.put("9", "September");
            mapOne.put("10", "Octomber");
            mapOne.put("11", "November");
            mapOne.put("12", "December");

            Iterator it = mapOne.entrySet().iterator();
            while(it.hasNext())
            {
                Map.Entry me = (Map.Entry) it.next();
                //System.out.println("Get Key through While loop = " + me.getKey());
            }
            for(Map.Entry<String, String> entry:mapOne.entrySet()){
                //System.out.println(entry.getKey() + "=" + entry.getValue());
            }

            for (Object key : mapOne.keySet()) {
                System.out.println("Key: " + key.toString() + " Value: " +
                                   mapOne.get(key));
            }
        }
    }

Comentarii

  • keySet() este lent –  > Por edin-m.
JohnK

Nu prea răspunde la întrebarea lui OP, dar ar putea fi util pentru alții care găsesc această pagină:

Dacă aveți nevoie doar de valori și nu de chei, puteți face acest lucru:

Map<Ktype, Vtype> myMap = [...];
for (Vtype v: myMap.values()) {
  System.out.println("value: " + v);
}

Ktype, , Vtype sunt un pseudocod.

Syd Lambert

Dacă doriți să iterați prin hartă în ordinea în care au fost adăugate elementele, utilizați LinkedHashMap spre deosebire de doar Map.

Această abordare a funcționat pentru mine în trecut:

LinkedHashMap<String,Integer> test=new LinkedHashMap();

test.put("foo",69);
test.put("bar",1337);

for(int i=0;i<test.size();i++){
    System.out.println(test.get(test.keySet().toArray()[i]));
}

Ieșire:

69
1337

fechidal89

Am copiat datele unei hărți în alta cu acest cod:

HashMap product =(HashMap)shopping_truck.get(i);
HashMap tmp = new HashMap();
for (Iterator it = product.entrySet().iterator(); it.hasNext();) {
    Map.Entry thisEntry = (Map.Entry) it.next();
    tmp.put(thisEntry.getKey(), thisEntry.getValue());
}

Joshua Michael Waggoner

Acesta este cel mai simplu mod de a face acest lucru, cred…

/* For example, this could be a map object */
Map<String, Integer> MAP = new Map<>();

// Do something like put keys/value pairs into the map, etc...
MAP.put("Denver", 35);
MAP.put("Patriots", 14);

/* Then, simply use a for each loop like this to iterate */
for (Object o : MAP.entrySet()) {
    Map.Entry pair = (Map.Entry) o;
    // Do whatever with the pair here (i.e. pair.getKey(), or pair.getValue();
}

Dubstep
Map<String, String> map = 
for (Map.Entry<String, String> entry : map.entrySet()) {
    MapKey = entry.getKey() 
    MapValue = entry.getValue();
}

Badri Paudel

Puteți căuta cheia și, cu ajutorul cheii, puteți găsi valoarea asociată hărții, deoarece harta are o cheie unică, , vedeți ce se întâmplă atunci când cheia este duplicată aici sau aici.

Hartă demonstrativă :

 Map<String, String> map = new HashMap();
  map.put("name", "Badri Paudel");
  map.put("age", "23");
  map.put("address", "KTM");
  map.put("faculty", "BE");
  map.put("major", "CS");
  map.put("head", "AVD");
 

Pentru a obține doar cheia, puteți utiliza map.keySet(); astfel :

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

Pentru a obține doar valoarea, puteți folosi map.values(); în felul următor:

      for(String value : map.values()) {
      System.out.println(value);
  }

Pentru a obține atât cheia, cât și valoarea acesteia, puteți folosi în continuare map.keySet(); și să obțineți valoarea corespunzătoare, astfel :

 //this prints the key value pair
  for (String k : map.keySet()) {
        System.out.println(k + " " + map.get(k) + " ");
    }

map.get(key) oferă valoarea indicată de cheia respectivă.