recorrer ¿Cómo iterar eficientemente sobre cada entrada en un mapa de Java?




recorrer list map java (24)

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

            }

Si tengo un objeto que implementa la interfaz del Map en Java y deseo recorrer cada par que contiene, ¿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 tengo para la interfaz?


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

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 compilador Map.Entry tipo de k y v , y ya no será necesario utilizar Map.Entry .

¡Pan comido!


Lambda Expression Java 8

En Java 1.8 (Java 8), esto se ha vuelto mucho más fácil utilizando el método forEach de las operaciones agregadas ( operaciones de secuencia ) que se parece a los iteradores de la interfaz iterable .

Simplemente copie la declaración que se encuentra debajo de su código y cambie el nombre de la variable HashMap de hm 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 ejemplo que probé con Lambda Expression . Esto es tan 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 usar Spliterator para el mismo.

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

ACTUALIZAR

Incluyendo enlaces de documentación a Oracle Docs. Para obtener más información sobre Lambda, vaya a este link y debe leer Operaciones de agregados y para Spliterator vaya a este link .


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

Hay varias formas de iterar sobre el mapa.

Aquí está la comparación de sus actuaciones para un conjunto de datos común almacenado en el mapa al almacenar un millón de pares de valores clave en el mapa y se repetirá 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() y el 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() y el iterador

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

75 milisegundos

He referido this link .


Si tienes un mapa genérico sin tipo puedes usar:

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

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

  //...
}

El ordenamiento siempre dependerá de la implementación específica del mapa. Usando Java 8 puedes usar 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 entrySet está respaldado por el mapa para que obtenga el mismo pedido. El segundo es práctico, ya que le permite usar lambdas, por ejemplo, si solo desea imprimir solo objetos de 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,

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,


En el Mapa, la Iteración sobre las keys y / o los values y / o both (eg, entrySet) depende del interés de uno en Me gusta:

1.) Iterar a través de las keys -> keySet() del mapa:

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

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

2.) Iterar a través de los values -> values() del mapa:

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

3.) Iterar a través de 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 como abajo _

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

Para su información, también puede usar map.keySet() y map.values() si solo está interesado en las claves / valores del mapa y no en el otro.


Esta es una pregunta de dos partes:

Cómo iterar sobre las entradas de un Mapa - @ ScArcher2 ha answered perfectamente.

¿Cuál es el orden de iteración ? Si solo está utilizando Map , entonces estrictamente hablando, no hay garantías de pedido . Por lo tanto, no debería confiar en el orden dado por cualquier implementación. Sin embargo, la interfaz de SortedMap amplía Map y proporciona exactamente lo que está buscando: las implementaciones siempre proporcionarán un orden de clasificación consistente.

NavigableMap es otra extensión útil : esta es una 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 la entry específica después de usar los higherEntry , lowerEntry , ceilingEntry o floorEntry . El método descendingMap incluso le brinda un método explícito para revertir el orden de recorrido .


Con java 8

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

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

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

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

La mejor manera es entrySet() sin embargo.


La forma correcta de hacer esto es usar la respuesta aceptada ya que es la más eficiente. Me parece que el siguiente código se ve un poco más limpio.

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

Con Eclipse Collections (anteriormente GS Collections ), usaría el método forEachKeyValue en la interfaz MapIterable , que es heredado por las interfaces MutableMap y 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 comendador de Eclipse Collections.


En Java 8 tenemos el método forEach que acepta una link . También tenemos APIs de stream . Considere un mapa:

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

Iterar sobre las teclas:

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

Iterar sobre los 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 con los flujos es que pueden ser paralelizados fácilmente en caso de que queramos. Simplemente necesitamos usar parallelStream() en lugar de stream() arriba.


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). SortedMap devolverá las entradas según el orden natural de las claves, o un Comparator , si se proporciona. LinkedHashMap devolverá las entradas en orden de inserción o orden 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: el iterador de IdentityHashMap entrySet actualmente tiene una implementación peculiar que devuelve la misma instancia Map.Entry para cada elemento en entrySet . Sin embargo, cada vez que un nuevo iterador avanza, Map.Entry se actualiza.


Java 8:

Puedes usar expresiones lambda:

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

Para más información, sigue this .


Utilice Java 8:

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

Sí, el orden depende de la implementación específica del Mapa.

@ ScArcher2 tiene la sintaxis más elegante de Java 1.5 . 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();
  // ...
}

Sí, ya que mucha gente estuvo de acuerdo en que esta es la mejor manera de recorrer un Map .

Pero hay posibilidades de lanzar nullpointerexception si el mapa es null . No olvides poner null .check.

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




iteration