Itera attraverso una HashMap [duplicato]
Possibile duplicato:
Come iterare in modo efficiente su ogni voce in una'Mappa'?
Qual è il modo migliore per scorrere gli elementi in un HashMap
?
7 answers
Itera attraverso il entrySet()
in questo modo:
public static void printMap(Map mp) {
Iterator it = mp.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pair = (Map.Entry)it.next();
System.out.println(pair.getKey() + " = " + pair.getValue());
it.remove(); // avoids a ConcurrentModificationException
}
}
Per saperne di più Map
.
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.