Itera attraverso una HashMap [duplicato]

Se sei interessato solo alle chiavi, puoi scorrere keySet() della mappa:

Map<String, Object> map = ...;

for (String key : map.keySet()) {
    // ...
}

Se hai solo bisogno dei valori, usa values():

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

Infine, se vuoi sia la chiave che il valore, usa entrySet():

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

Un avvertimento: se si desidera rimuovere gli elementi a metà iterazione, è necessario farlo tramite un iteratore (vedere la risposta di karim79). Tuttavia, la modifica dei valori degli elementi è OK (vedere Map.Entry).

Estratto dal riferimento Come iterare su una mappa in Java:

Ci sono diversi modi di iterare su un Map in Java. Andiamo oltre i metodi più comuni e rivedere i loro vantaggi e svantaggi. Poiché tutte le mappe in Java implementano l'interfaccia della mappa, le seguenti tecniche funzioneranno per qualsiasi implementazione della mappa(HashMap, TreeMap, LinkedHashMap, Hashtable, ecc.)

Metodo #1: iterazione su voci utilizzando un For-Each loop.

Questo è il metodo più comune ed è preferibile nella maggior parte dei casi. Dovrebbe essere usato se hai bisogno sia delle chiavi della mappa che dei valori nel ciclo.

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

Si noti che il ciclo For-Each è stato introdotto in Java 5, quindi questo metodo funziona solo nelle versioni più recenti della lingua. Anche un ciclo For-Each genererà NullPointerException se si tenta di iterare su una mappa che è null, quindi prima di iterare si dovrebbe sempre verificare la presenza di riferimenti null.

Metodo #2: iterazione su chiavi o valori che utilizzano un ciclo For-Each.

Se hai bisogno solo di chiavi o valori dalla mappa, puoi iterare su keySet o values invece di entrySet.

Map<Integer, Integer> map = new HashMap<Integer, Integer>();

// Iterating over keys only
for (Integer key : map.keySet()) {
    System.out.println("Key = " + key);
}

// Iterating over values only
for (Integer value : map.values()) {
    System.out.println("Value = " + value);
}

Questo metodo offre un leggero vantaggio in termini di prestazioni rispetto all'iterazione entrySet (circa il 10% più veloce) ed è più pulito.

Metodo # 3: Iterazione utilizzando Iteratore.

Utilizzo di farmaci generici:

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

Senza generici:

Map map = new HashMap();
Iterator entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = (Map.Entry) entries.next();
    Integer key = (Integer)entry.getKey();
    Integer value = (Integer)entry.getValue();
    System.out.println("Key = " + key + ", Value = " + value);
}

Puoi anche usare la stessa tecnica per scorrere keySet o valore.

Questo metodo potrebbe sembrare ridondante, ma ha i suoi vantaggi. Prima di tutto, è l'unico modo per iterare su una mappa nelle versioni precedenti di Java. L'altra caratteristica importante è che è l'unico metodo che consente di rimuovere le voci dalla mappa durante l'iterazione chiamando iterator.remove(). Se provi a farlo durante For-Ogni iterazione otterrai "risultati imprevedibili" secondo Javadoc.

Da un punto di vista delle prestazioni questo metodo è uguale a a per-Ogni iterazione.

Metodo # 4: iterazione su chiavi e ricerca di valori (inefficiente).

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Integer key : map.keySet()) {
    Integer value = map.get(key);
    System.out.println("Key = " + key + ", Value = " + value);
}

Potrebbe sembrare un'alternativa più pulita per il metodo n.1, ma in pratica è piuttosto lento e inefficiente poiché ottenere valori da una chiave potrebbe richiedere molto tempo (questo metodo in diverse implementazioni di mappe è del 20% -200% più lento del metodo n. 1). Se hai installato FindBugs, lo rileverà e ti avviserà dell'iterazione inefficiente. Questo metodo dovrebbe essere evitare.

Conclusione:

Se hai bisogno solo di chiavi o valori dalla mappa, usa il metodo #2. Se si è bloccati con la versione precedente di Java (meno di 5) o si pianifica di rimuovere le voci durante l'iterazione, è necessario utilizzare il metodo #3. In caso contrario, utilizzare il metodo #1.

for (Map.Entry<String, String> item : params.entrySet()) {
    String key = item.getKey();
    String value = item.getValue();
}

È possibile scorrere le voci in un Map in diversi modi. Ottieni ogni chiave e valore in questo modo:

Map<?,?> map = new HashMap<Object, Object>();
for(Entry<?, ?> e: map.entrySet()){
    System.out.println("Key " + e.getKey());
    System.out.println("Value " + e.getValue());
}

Oppure puoi ottenere l'elenco delle chiavi con

Collection<?> keys = map.keySet();
for(Object key: keys){
    System.out.println("Key " + key);
    System.out.println("Value " + map.get(key));
}

Se vuoi solo ottenere tutti i valori e non ti occupi delle chiavi, puoi usare:

Collection<?> values = map.values();

Più intelligente:

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

Dipende. Se sai che avrai bisogno sia della chiave che del valore di ogni voce, passa attraverso entrySet. Se hai solo bisogno dei valori, allora c'è il metodo values(). E se hai solo bisogno delle chiavi, usa keyset().

Una cattiva pratica sarebbe quella di scorrere tutte le chiavi, e quindi all'interno del ciclo, fare sempre map.get(key) per ottenere il valore. Se lo stai facendo, allora la prima opzione che ho scritto è per te.