¿Cómo puedo iterar de manera eficiente sobre cada entrada en un mapa de Java?
https://stackoverflow.com/questions/46898
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Si tengo un objeto que implementa el Map interfaz en Java y deseo iterar sobre cada par contenido en ella, ¿cuál es la forma más eficiente de recorrer el mapa?
¿El orden de los elementos dependerá de la implementación del mapa específico que tenga para la interfaz?
Solución
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
Otros consejos
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:
Usando iterador y Mapa.Entrada
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(); }Usando para cada y Mapa.Entrada
long i = 0; for (Map.Entry<Integer, Integer> pair : map.entrySet()) { i += pair.getKey() + pair.getValue(); }Usando para cada desde Java 8
final long[] i = {0}; map.forEach((k, v) -> i[0] += k + v);Usando juego de llaves y para cada
long i = 0; for (Integer key : map.keySet()) { i += key + map.get(key); }Usando 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); }Usando para y Mapa.Entrada
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 API de transmisión
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());Usando Mapa iterable de
Apache Collectionslong i = 0; MapIterator<Integer, Integer> it = iterableMap.mapIterator(); while (it.hasNext()) { i += it.next() + it.getValue(); }Usando Mapa mutable 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 3,60 GHz, 16 GB)
Para mapas pequeños (100 elementos), la puntuación 0,308 es la 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/opPara un 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/opPara un mapa con 100.000 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 marcha GitHub.
En Java 8 puedes hacerlo de forma limpia y rápida utilizando las nuevas funciones 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 es necesario utilizar Map.Entry ya no.
¡Pan comido!
Sí, el orden depende de la implementación específica del mapa.
@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();
// ...
}
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 ofrece garantías (o aunque no debería cambiar el orden si no se realiza ninguna operación de mutación en él). SortedMap devolverá entradas basadas en el orden natural de las claves, o una Comparator, si se proporciona. LinkedHashMap devolverá entradas en orden de inserción o en orden de acceso dependiendo de cómo se haya construido. EnumMap devuelve entradas en el orden natural de las claves.
(Actualizar:Creo que esto ya no es cierto.) Nota, IdentityHashMap entrySet El iterador actualmente tiene una implementación peculiar que devuelve lo mismo. Map.Entry instancia para cada elemento del entrySet!Sin embargo, cada vez que un nuevo iterador avanza Map.Entry está actualizado.
Ejemplo de uso de iteradores 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();
// ...
}
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, entonces estrictamente hablando, hay sin garantías de pedido.Por lo tanto, no debería confiar en el orden dado por ninguna implementación.sin embargo, el SortedMap la interfaz se extiende Map y proporciona exactamente lo que está buscando: las implementaciones siempre brindarán un orden de clasificación consistente.
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.Entonces, potencialmente, esto puede eliminar la necesidad de iterar en primer lugar; es posible que pueda encontrar el archivo específico entry estás después de usar el higherEntry, lowerEntry, ceilingEntry, o floorEntry métodos.El descendingMap El método incluso te proporciona un método explícito de invertir el orden transversal.
Hay varias formas de iterar sobre el mapa.
Aquí se compara su rendimiento para un conjunto de datos común almacenado en el mapa almacenando un millón de pares clave-valor en el mapa y se iterará sobre el mapa.
1) Usando entrySet() en para cada bucle
for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
entry.getKey();
entry.getValue();
}
50 milisegundos
2) Usando keySet() en para 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.
La forma correcta de hacerlo es utilizar 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));
}
Para su información, también puede utilizar map.keySet() y map.values() si solo está interesado en las claves/valores del mapa y no en el otro.
Con Colecciones de eclipses (antes Colecciones GS), usaría el método forEachKeyValue en el MapaIterable interfaz, que es 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, puedes 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 confirmador de las colecciones de Eclipse.
En teoría, la forma más eficiente dependerá de qué implementación de Map.La forma oficial de hacer esto es llamar map.entrySet(), que devuelve un conjunto de Map.Entry, cada uno de los cuales contiene una clave y un valor (entry.getKey() y entry.getValue()).
En una implementación idiosincrásica, podría haber alguna diferencia si usa map.keySet(), map.entrySet() o algo mas.Pero no se me ocurre ninguna razón por la que alguien lo escribiría así.Lo más probable es que lo que hagas no influya en el rendimiento.
Y sí, el orden dependerá de la implementación, así como (posiblemente) del orden de inserción y otros factores difíciles de controlar.
[editar] escribí valueSet() originalmente pero claro entrySet() es en realidad la respuesta.
Java 8:
Puedes utilizar expresiones lambda:
myMap.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
});
Para más información, sigue este.
Pruebe esto con Java 1.4:
for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){
Entry entry = (Entry) entries.next();
System.out.println(entry.getKey() + "/" + entry.getValue());
//...
}
Con Java 8
map.forEach((k, v) -> System.out.println((k + ":" + v)));
Java 8
Tenemos forEach método que acepta un expresión lambda.También tenemos arroyo API.Considere un mapa:
Map<String,String> sample = new HashMap<>();
sample.put("A","Apple");
sample.put("B", "Ball");
Iterar sobre claves:
sample.keySet().forEach((k) -> System.out.println(k));
Iterar sobre valores:
sample.values().forEach((v) -> System.out.println(v));
Iterar sobre las entradas (usando forEach y 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);
});
La ventaja de los flujos es que se pueden paralelizar fácilmente en caso de que queramos.Simplemente necesitamos usar parallelStream() en lugar de stream() arriba.
forEachOrdered vs forEach con corrientes?El forEach no sigue el orden de encuentro (si está definido) y es inherentemente de naturaleza no determinista, donde como forEachOrdered hace.Entonces forEach no garantiza que el pedido se mantenga.También verifique este para más.
lambda Expresión Java 8
En Java 1.8 (Java 8) esto se ha vuelto mucho más fácil usando para cada método de operaciones agregadas (Operaciones de flujo) que se parece a los iteradores de iterable Interfaz.
Simplemente copie y pegue la siguiente declaración en su código y cambie el nombre del HashMap variable de mmm a su variable HashMap para imprimir el par clave-valor.
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.
A continuación se muestra el código de muestra que intenté usar. Expresión lambda.Esto es genial.Deberías intentar.
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
También se puede utilizar Separador por lo mismo.
Spliterator sit = hm.entrySet().spliterator();
ACTUALIZAR
Incluyendo enlaces de documentación a Oracle Docs.Para más información lambda ve a esto enlace y debe leer Operaciones agregadas y para Spliterator ve a esto enlace.
En el mapa se puede iterar keys y/o values y/o both (e.g., entrySet) depende del interés de cada uno_ Me gusta:
1.) Iterar a través del keys -> keySet() del mapa:
Map<String, Object> map = ...;
for (String key : map.keySet()) {
//your Business logic...
}
2.) Iterar a través del values -> values() del mapa:
for (Object value : map.values()) {
//your Business logic...
}
3.) Iterar a través del both -> entrySet() del mapa:
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
//your Business logic...
}
Además, hay 3 formas diferentes de iterar a través de un HashMap.Son los siguientes_
//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);
}
Más compacto con Java 8:
map.entrySet().forEach(System.out::println);
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);
}
}
}
O
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();
}
}
}
Si tiene un mapa genérico sin tipo, puede usar:
Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
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());
}
Puedes hacerlo usando genéricos:
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());
}
Utilice Java 8:
map.entrySet().forEach(entry -> System.out.println(entry.getValue()));
//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();
}
El orden siempre dependerá de la implementación específica del mapa.Con Java 8 puedes utilizar cualquiera de estos:
map.forEach((k,v) -> { System.out.println(k + ":" + v); });
O:
map.entrySet().forEach((e) -> {
System.out.println(e.getKey() + " : " + e.getValue());
});
El resultado será el mismo (mismo orden).El conjunto de entrada está respaldado por el mapa para que obtenga el mismo pedido.El segundo es útil ya que le permite utilizar lambdas, p.Si solo desea imprimir objetos enteros mayores que 5:
map.entrySet()
.stream()
.filter(e-> e.getValue() > 5)
.forEach(System.out::println);
El siguiente código muestra la iteración a través de LinkedHashMap y HashMap normal (ejemplo).Verás la diferencia en el orden:
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() + ", ");
});
}
}
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,
Mapa Hash (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,
Mapa Hash (2):
0 : 0, 1 : 1, 2 : 2, 3 : 3, 4 : 4, 5 : 5, 6 : 6, 7 : 7, 8 : 8, 9 : 9, 10 : 10,
Una solución iterativa eficaz sobre un mapa es un bucle "para cada" desde Java 5 hasta Java 7.Aquí lo tienes:
for (String key : phnMap.keySet()) {
System.out.println("Key: " + key + " Value: " + phnMap.get(key));
}
Desde Java 8 puedes usar una expresión lambda para iterar sobre un mapa.Es un 'forEach' mejorado
phnMap.forEach((k,v) -> System.out.println("Key: " + k + " Value: " + v));
Si desea escribir un condicional para lambda, puede escribirlo así:
phnMap.forEach((k,v)->{
System.out.println("Key: " + k + " Value: " + v);
if("abc".equals(k)){
System.out.println("Hello abc");
}
});
Sí, como mucha gente estuvo de acuerdo, esta es la mejor manera de iterar sobre un Map.
Pero hay posibilidades de tirar nullpointerexception si el mapa es null.No olvides poner null .registrarse.
|
|
- - - -
|
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
}
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));
}
}
Hay muchas maneras de hacer esto.A continuación se muestran algunos pasos simples:
Supongamos que tiene un mapa como:
Map<String, Integer> m = new HashMap<String, Integer>();
Luego puedes hacer algo como lo siguiente para iterar sobre los elementos del mapa.
// ********** 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));
}
