1. Un conjunto de pares clave-valor.

Un conjunto de pares clave-valor

En Java, otra colección interesante (en términos generales) es Map. A veces, esta estructura de datos también se denomina diccionario.

Es similar a la Setcolección, pero almacena un conjunto de "pares" de elementos en lugar de un conjunto de elementos. Cada par en consta Mapde dos elementos: una "clave" y un "valor".

Supongamos que desea que su programa almacene los nombres de los empleados y sus salarios, o los nombres de sus compañeros de trabajo y sus edades. Entonces necesitarías una tabla como esta:

Nombre Edad
Elón 21
jeff 22
Factura 48
Madriguera ?

Cada fila contiene un par de valores. Nos referiremos al nombre como la clave del par y a la edad como el valor del par .

El conjunto completo de estos pares es nuestro mapa ( Map).

La clave de un par puede ser cualquier cosa excepto null. Las claves deben ser únicas: un mapa no puede contener dos claves idénticas.


2. HashMapclase

La HashMapclase es el tipo de colección más popular Map. Por un lado, es muy similar a HashSet y tiene todos sus métodos. Por otro lado, es como una lista ( ArrayList) que puede usar palabras (o cualquier otra cosa) como índices.

Puede crear un HashMapuso de una declaración como esta:

HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();

Donde KeyTypees el tipo de las claves en los pares almacenados y ValueTypees el tipo de los valores en los pares almacenados en la HashMapcolección.

La HashMapclase tiene métodos como este:

Método Descripción
void put(KeyType key, ValueType value)
Agrega el par ( key, value) a la colección.
ValueType get(KeyType key)
Devuelve el valor asociado a una clave.
boolean containsKey(KeyType key)
Comprueba si existe una clave en la colección.
boolean containsValue(ValueType value)
Comprueba la existencia de un valor en la colección.
ValueType remove(KeyType key)
Elimina un elemento de la colección.
void clear()
Borra la colección, eliminando todos los elementos.
int size()
Devuelve el número de pares clave-valor en la colección.
Set<KeyType> keySet()
Devuelve el conjunto de claves de la colección.
Collection<ValueType> values()
Devuelve un conjunto que contiene los elementos de la colección.
Set<Map.Entry<KeyType, ValueType>> entrySet()
Devuelve un conjunto ( Set) de todos los pares ( Map.Entry) de la colección.

Adición de elementos a unHashMap

Los elementos se agregan a un mapa como pares usando el put()método. La clave se pasa como el primer argumento y el valor se pasa como el segundo.

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Al agregar un par clave-valor, si la clave ya existe en la colección, el valor anterior se reemplaza por el valor nuevo.

Este comportamiento hace HashMapcomo una matriz o una lista cuyos índices son palabras ( String) en lugar de números.

Importante:

Casi cualquier tipo puede ser KeyType o ValueType. Hay algunos pequeños requisitos adicionales para KeyType, y aprenderá sobre ellos cuando estudie las colecciones con mayor detalle en la búsqueda de colecciones de Java.



3. Subconjuntos de a HashMap: el conjunto de claves

Digamos que solo queremos mostrar todas las entradas en a HashMapen la pantalla. Cómo hacemos esto? Para hacer esto, necesitamos saber cómo revisar todas las entradas en el archivo HashMap. Esto se puede hacer de varias maneras.

La forma más fácil es hacer un bucle sobre las teclas.

HashMaplas entradas no están numeradas secuencialmente, por lo que un ciclo con un contador no funcionará aquí. Pero podemos obtener un conjunto de claves usando el keySet()método, y ya sabes cómo iterar sobre un conjunto:

Código Descripción
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}






Recorra las claves del map

Obtener el valor asociado con la clave

El keySet()método devuelve un conjunto de claves. Puede utilizar este conjunto de dos maneras:

Notación compacta notación larga
for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}
Set<String> keys = map.keySet();

for (String key: keys)
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}


4. Bucles sobre pares clave-valor

También hay una forma más complicada: puede transformar a Mapen un conjunto de pares clave-valor y luego recorrer los elementos del conjunto, como ya hemos aprendido.

La HashMapcolección tiene una clase auxiliar que almacena un par clave-valor. Se ve aproximadamente así:

class Entry<KeyType, ValueType>
{
   private KeyType key;
   private ValueType value;

   public KeyType getKey()
   {
      return this.key;
   }

   public ValueType getValue()
   {
      return this.value;
   }
}

El resultado de llamar al entrySet()método en un objeto será un :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

Set<Entry<KeyType, ValueType>> name = map.entrySet();

Aquí tenemos la Setclase genérica con un parámetro de tipo, que a su vez es un tipo genérico ( Entry) con dos parámetros de tipo.

Es muy fácil que un principiante se confunda con esto. Pero una vez que lo descubras, puedes escribir código como:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> pair: entries)
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

Dicho esto, este código se puede simplificar un poco:

Primero, puede omitir la creación de una variable separada para entriesy, en su lugar, llamar al entrySet()método directamente dentro del forciclo:

for(Map.Entry<String, Integer> pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

En segundo lugar, puede utilizar el varoperador introducido recientemente para inferir automáticamente el tipo de par clave-valor :

for(var pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

No está mal, ¿eh?



5. Comparación de ArrayListyHashMap

A se HashMapparece mucho a an ArrayListque permite usar cadenas (u otros tipos) como índices (las claves).

Si usa Integerpara las claves en a HashMap, entonces se vuelve aún más similar a an ArrayList. Comparemos:

Código con ArrayList<String> Código con HashMap<Integer, String>
ArrayList<String> list = new ArrayList<String>();

list.add("Greetings");
list.add("Hello");

String s = list.get(0);
list.set(0, s + "!");

for (String item: list)
{
   System.out.println(item);
}
HashMap<Integer, String> map = new HashMap<Integer, String>();

map.put(0, "Greetings");
map.put(1, "Hello");

String s = map.get(0);
map.put(0, s + "!");

for (String item: map.values())
{
   System.out.println(item);
}