Introducción a la colección HashMap

1. 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:

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:

void put(KeyType key, ValueType value)

ValueType get(KeyType key)

boolean containsKey(KeyType key)

boolean containsValue(ValueType value)

ValueType remove(KeyType key)

void clear()

int size()

Set<KeyType> keySet()

Collection<ValueType> values()

Set<Map.Entry<KeyType, ValueType>> entrySet()

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.

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:

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

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

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:

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