Pregunta ¿Cómo iterar eficientemente sobre cada entrada en un 'Mapa'?
Si tengo un objeto que implementa el Map
interfaz en Java y deseo iterar sobre cada par contenido en él, ¿cuál es la forma más eficiente de pasar por el mapa?
¿El orden de los elementos dependerá de la implementación del mapa específico que tengo para la interfaz?
2523
2017-09-05 21:12
origen
Respuestas:
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet())
{
System.out.println(entry.getKey() + "/" + entry.getValue());
}
4088
2017-09-05 21:15
Para resumir las otras respuestas y combinarlas con lo que sé, encontré 10 formas principales de hacerlo (ver más abajo). Además, escribí algunas pruebas de rendimiento (ver resultados a continuación). Por ejemplo, si queremos encontrar la suma de todas las claves y valores de un mapa, podemos escribir:
Utilizando iterador y 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();
}
Utilizando para cada y Map.Entry
long i = 0;
for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
i += pair.getKey() + pair.getValue();
}
Utilizando para cada de Java 8
final long[] i = {0};
map.forEach((k, v) -> i[0] += k + v);
Utilizando juego de llaves y para cada
long i = 0;
for (Integer key : map.keySet()) {
i += key + map.get(key);
}
Utilizando juego de llaves y iterador
long i = 0;
Iterator<Integer> itr2 = map.keySet().iterator();
while (itr2.hasNext()) {
Integer key = itr2.next();
i += key + map.get(key);
}
Utilizando para y 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();
}
Usando Java 8 Stream API
final long[] i = {0};
map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
Usando Java 8 Stream API paralelo
final long[] i = {0};
map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());
Utilizando IterableMapa de Apache Collections
long i = 0;
MapIterator<Integer, Integer> it = iterableMap.mapIterator();
while (it.hasNext()) {
i += it.next() + it.getValue();
}
Utilizando MutableMap de colecciones de Eclipse (CS)
final long[] i = {0};
mutableMap.forEachKeyValue((key, value) -> {
i[0] += key + value;
});
Pruebas de rendimiento (modo = Tiempo promedio, sistema = Windows 8.1 de 64 bits, Intel i7-4790 de 3.60 GHz, 16 GB)
Para un mapa pequeño (100 elementos), el puntaje 0.308 es el mejor
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
Para el mapa con 10000 elementos, la puntuación 37.606 es la mejor
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
Para el mapa con 100000 elementos, la puntuación 1184.767 es la mejor
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
Gráficos (pruebas de rendimiento según el tamaño del mapa)

Tabla (pruebas de rendimiento según el tamaño del mapa)
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
Todas las pruebas están en GitHub.
672
2018-02-22 16:37
En Java 8 puedes hacerlo limpio y rápido usando las nuevas características de 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));
El tipo de k
y v
será inferido por el compilador y no hay necesidad de usar Map.Entry
nunca más.
¡Pan comido!
227
2017-10-21 10:15
Sí, el orden depende de la implementación del Mapa específico.
@ ScArcher2 tiene la sintaxis Java 1.5 más elegante. En 1.4, haría algo como esto:
Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Entry thisEntry = (Entry) entries.next();
Object key = thisEntry.getKey();
Object value = thisEntry.getValue();
// ...
}
196
2017-09-05 21:15
El código típico para iterar sobre un mapa es:
Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
String key = entry.getKey();
Thing thing = entry.getValue();
...
}
HashMap
es la implementación del mapa canónico y no hace garantías (o aunque no debería cambiar el orden si no se realiza una operación de mutación). SortedMap
devolverá entradas basadas en el orden natural de las teclas, o un Comparator
, si se proporciona LinkedHashMap
devolverá las entradas en orden de inserción o de acceso dependiendo de cómo se haya construido. EnumMap
devuelve las entradas en el orden natural de las claves.
(Actualización: creo que esto ya no es cierto.) Nota, IdentityHashMap
entrySet
iterator actualmente tiene una implementación peculiar que devuelve el mismo Map.Entry
instancia para cada elemento en el entrySet
! Sin embargo, cada vez que un nuevo iterador avanza, Map.Entry
esta actualizado
100
2017-09-05 21:26
Ejemplo de uso de iterador y genéricos:
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();
// ...
}
89
2017-08-18 17:34
Esta es una pregunta de dos partes:
Cómo iterar sobre las entradas de un Mapa - @ ScArcher2 tiene contestada eso perfectamente
¿Cuál es el orden de iteración? - si solo estás usando Map
, en rigor, hay sin pedir garantías. Entonces, realmente no deberías confiar en el orden dado por cualquier implementación. sin embargo, el SortedMap
la interfaz se extiende Map
y proporciona exactamente lo que está buscando: las implementaciones siempre le darán un orden de clasificación coherente.
NavigableMap
es otra extensión útil - esto es un SortedMap
con métodos adicionales para encontrar entradas por su posición ordenada en el conjunto de claves. Así que, potencialmente, esto puede eliminar la necesidad de iterar en primer lugar, es posible que pueda encontrar el específico entry
estás después de usar el higherEntry
, lowerEntry
, ceilingEntry
, o floorEntry
métodos. los descendingMap
método incluso le da un método explícito de invirtiendo la orden transversal.
76
2017-09-05 22:15
Hay varias formas de iterar sobre el mapa.
Aquí hay una comparación de sus actuaciones para un conjunto de datos comunes almacenados en el mapa al almacenar un millón de pares de valores clave en el mapa y se repetirán sobre el mapa.
1) Usando entrySet()
en cada bucle
for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
entry.getKey();
entry.getValue();
}
50 milisegundos
2) Usando keySet()
en cada bucle
for (String key : testMap.keySet()) {
testMap.get(key);
}
76 milisegundos
3) Usando entrySet()
e iterador
Iterator<Map.Entry<String,Integer>> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
Map.Entry<String,Integer> entry = itr1.next();
entry.getKey();
entry.getValue();
}
50 milisegundos
4) Usando keySet()
e iterador
Iterator itr2 = testMap.keySet().iterator();
while(itr2.hasNext()) {
String key = itr2.next();
testMap.get(key);
}
75 milisegundos
Me he referido this link
.
62
2018-02-05 06:42
FYI, también puedes usar map.keySet()
y map.values()
si solo está interesado en las claves / valores del mapa y no en el otro.
41
2017-09-05 22:27
La forma correcta de hacerlo es usar la respuesta aceptada, ya que es la más eficiente. Creo que el siguiente código parece un poco más limpio.
for (String key: map.keySet()) {
System.out.println(key + "/" + map.get(key));
}
40
2017-09-07 19:48
Con Colecciones Eclipse (antes Colecciones GS), usaría el método forEachKeyValue en MapIterable interfaz, heredada por las interfaces MutableMap e ImmutableMap y sus implementaciones.
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);
Con la sintaxis lambda de Java 8, puede escribir el código de la siguiente manera:
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);
Nota: Soy un committer para colecciones de Eclipse.
22
2017-12-18 23:13