java recorrer - Iterar a través de un HashMap




foreach ejemplo (7)

Posible duplicado:
¿Cómo iterar eficientemente cada entrada en un 'Mapa'?

¿Cuál es la mejor manera de iterar sobre los elementos en un HashMap ?


Answers

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

Depende. Si sabe que va a necesitar tanto la clave como el valor de cada entrada, vaya a la entrada entrySet . Si solo necesitas los valores, entonces está el método de values() . Y si solo necesita las teclas, use keyset() .

Una mala práctica sería iterar a través de todas las claves, y luego dentro del bucle, siempre haga map.get(key) para obtener el valor. Si estás haciendo eso, entonces la primera opción que escribí es para ti.


Iterar a través del entrySet() manera:

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
    }
}

Leer más sobre Map .


Puede iterar a través de las entradas en un Map de varias maneras. Obtenga cada clave y valor de esta manera:

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

O puede obtener la lista de claves con

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

Si solo desea obtener todos los valores y no está preocupado por las claves, puede usar:

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

Más inteligente

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

Extraído de la referencia Cómo iterar sobre un mapa en Java :

Hay varias formas de iterar sobre un Map en Java. Vamos a repasar los métodos más comunes y revisar sus ventajas y desventajas. Dado que todos los mapas en Java implementan la interfaz de mapas, las siguientes técnicas funcionarán para cualquier implementación de mapas ( HashMap , TreeMap , LinkedHashMap , Hashtable , etc.)

Método # 1 : Iterando sobre entradas usando un bucle For-Each.

Este es el método más común y es preferible en la mayoría de los casos. Se debe utilizar si necesita claves de mapa y valores en el bucle.

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

Tenga en cuenta que el bucle For-Each se introdujo en Java 5, por lo que este método funciona solo en las versiones más nuevas del lenguaje. Además, un bucle For-Each arrojará NullPointerException si intenta iterar sobre un mapa que es nulo, por lo que antes de iterar siempre debe verificar las referencias nulas.

Método # 2 : Iterar sobre claves o valores utilizando un bucle For-Each.

Si solo necesita claves o valores del mapa, puede iterar sobre keySet o valores en lugar de 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);
}

Este método proporciona una ligera ventaja de rendimiento sobre la iteración de entrada de entrySet (aproximadamente un 10% más rápido) y es más limpio.

Método # 3 : Iterando usando el iterador.

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

Sin genéricos:

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

También puede utilizar la misma técnica para iterar sobre keySet o valores.

Este método puede parecer redundante, pero tiene sus propias ventajas. En primer lugar, es la única forma de iterar sobre un mapa en versiones anteriores de Java. La otra característica importante es que es el único método que le permite eliminar entradas del mapa durante la iteración llamando a iterator.remove() . Si intenta hacer esto durante la iteración For-Each, obtendrá "resultados impredecibles" según Javadoc .

Desde el punto de vista del rendimiento, este método es igual a una iteración For-Each.

Método # 4 : Iterando sobre las teclas y buscando valores (ineficientes).

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

Esto podría parecer una alternativa más limpia para el método # 1, pero en la práctica es bastante lento e ineficiente, ya que obtener valores con una clave puede llevar mucho tiempo (este método en diferentes implementaciones de mapas es 20% -200% más lento que el método # 1 ). Si tiene instalado FindBugs, detectará esto y le advertirá sobre una iteración ineficiente. Este método debe ser evitado.

Conclusión:

Si solo necesita claves o valores del mapa, use el método # 2. Si está atascado con una versión anterior de Java (menos de 5) o planea eliminar entradas durante la iteración, debe utilizar el método # 3. De lo contrario, utilice el método # 1.


Puede usar el iterador directamente como lo mencionó, o bien mantener una segunda colección y agregar cada elemento que desee eliminar a la nueva colección, luego eliminar todo al final. Esto le permite seguir usando la seguridad de tipos del bucle for-each a costa de un mayor uso de memoria y tiempo de CPU (no debería ser un gran problema a menos que tenga listas realmente grandes o una computadora muy vieja)

public static void main(String[] args)
{
    Collection<Integer> l = new ArrayList<Integer>();
    Collection<Integer> itemsToRemove = new ArrayList<Integer>();
    for (int i=0; i < 10; ++i) {
    l.add(new Integer(4));
    l.add(new Integer(5));
    l.add(new Integer(6));
    }
    for (Integer i : l)
    {
        if (i.intValue() == 5)
            itemsToRemove.add(i);
    }

    l.removeAll(itemsToRemove);
    System.out.println(l);
}






java loops hashmap iteration