HashMap: ¿qué tipo de mapa es este?

¡Hola! En esta lección, haremos una revisión más detallada en Java HashMap . Previamente, hemos estudiado estructuras de datos donde los elementos se almacenan como ellos mismos. En una matriz o ArrayList / LinkedList , almacenamos una cierta cantidad de elementos. Pero, ¿y si nuestra tarea cambia un poco? Imagine la siguiente tarea: cree una lista de 100 personas que almacene el nombre y el número de pasaporte de cada persona. En principio, esto no es tan difícil. Por ejemplo, puede incluir ambos en una cadena y luego crear una lista de estas cadenas: "Amelia Aguilar, 4211 717171". Pero esta solución tiene dos inconvenientes. Primero, es posible que necesitemos la capacidad de buscar por número de pasaporte. Y esto será problemático dado este formato de almacenamiento de información. En segundo lugar, nada nos impide crear dos personas diferentes con el mismo número de pasaporte. Y este es el defecto más grave de nuestra solución. Esto nunca debe permitirse: no hay dos personas que tengan el mismo número de pasaporte. Una nueva estructura de datos viene en nuestra ayuda: Mapa. También se conoce como "matriz asociativa", pero este término se usa con poca frecuencia. Más comúnmente, se le llama "diccionario" o "mapa". :) ¿En qué se diferencia fundamentalmente de las estructuras de datos que hemos considerado anteriormente? Sobre todo, en el hecho de que los datos de un Mapa se almacenan como pares clave-valor. Cualquier cosa puede servir como claves y valores: números, cadenas u objetos de otras clases. Hoy estudiaremos la implementación más común de la clase Map : Java HashMap .

Entonces, ¿qué necesitamos saber sobre HashMap en Java?

Es muy fácil de crear:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
}

Aquí creamos un diccionario que almacena elementos como pares de "cadena de números". El número actuará como clave y la cadena como valor. También especificamos el tipo de clave (Entero) y el tipo de valor (Cadena). ¿Por qué? Primero, una clave HashMap siempre es única. Esto nos viene perfecto, ya que podemos utilizar el número de pasaporte como clave y evitar duplicados. El valor será una cadena con el nombre completo (diferentes personas pueden tener el mismo nombre, eso no es nada de lo que debamos preocuparnos). Agregar un nuevo par al HashMap se ve así:

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");
       System.out.println(passportsAndNames);
   }
}

Usamos el método put() para esto. Además, HashMap anula el método toString() , por lo que se puede mostrar en la consola. La salida se verá así: {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Ivan the Great} Ahora, verifiquemos si las claves son realmente únicas. Intentemos agregar un nuevo elemento con una clave que ya se haya utilizado en el mapa:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");
   passportsAndNames.put(162348, "Albert Kent");// This key has already been used
   System.out.println(passportsAndNames);
}

Salida: {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Albert Kent} Como puede ver, el valor anterior asociado con la clave 162348 se sobrescribió. Usamos el término "clave" por una razón. Se accede a los valores en un HashMap usando la clave, pero no al revés. La clave no se puede obtener usando un valor, ya que los valores pueden no ser únicos. Esto se puede ver claramente al obtener o eliminar un elemento del HashMap :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   String lidiaName = passportsAndNames.get(212133);
   System.out.println(lidiaName);

   passportsAndNames.remove(162348);
   System.out.println(passportsAndNames);
}

Para obtener un valor o eliminar un par del diccionario, debemos pasar a get() y remove() la clave única que corresponde al valor. A diferencia de las matrices y las listas, un HashMap en Java no tiene índices numéricos: se accede a los valores usando la clave. Salida de la consola: Bridget Logan {212133=Bridget Logan, 8082771=Donald John Trump} Las clases ArrayList y LinkedList nos permiten verificar si la lista contiene algún elemento en particular. Java HashMap nos permite hacer esto. Además, podemos hacer esto para ambos miembros del par: esto es lo que contiene la clave () (busca una clave) y contiene el valor ()(comprueba un valor) los métodos son para.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.containsKey(11111));
   System.out.println(passportsAndNames.containsValue("Donald John Trump"));
}

Salida: falso verdadero Otra característica conveniente de HashMap en Java es el hecho de que puede obtener listas separadas de todas las claves y todos los valores. Esto se logra con los métodos keySet() y values() :

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");

       Set keys = passportsAndNames.keySet();
       System.out.println("Keys: " + keys);

       ArrayList<String> values = new ArrayList<>(passportsAndNames.values());
       System.out.println("Values: " + values);
   }
}

Las claves se extraen en un Set , que aún no hemos cubierto. Es especial porque no puede contener elementos repetitivos. Ahora, lo principal es recordar que la lista de todas las claves se puede recuperar de un HashMap en una colección separada. En el ejemplo, guardamos los valores en un ArrayList ordinario . Salida de la consola: Claves: [212133, 8082771, 162348] Valores: [Bridget Logan, Donald John Trump, Ivan the Great] Los métodos size() y clear() hacen exactamente lo mismo que en las estructuras anteriores que hemos discutido: el primero devuelve el número de elementos actualmente en el diccionario, el segundo elimina todos los elementos.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.size());
   passportsAndNames.clear();
   System.out.println(passportsAndNames);
}

Salida: 3 {} Para verificar si hay al menos un elemento en nuestro HashMap , podemos usar el método isEmpty() :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   if (!passportsAndNames.isEmpty()) {

       System.out.println(passportsAndNames);
   }
}

Salida: {212133=Bridget Logan, 8082771=Donald John Trump, 162348=Ivan the Great} Ahora solo enviaremos la salida a la consola después de una verificación preliminar. :) Otro punto interesante es que se pueden combinar dos mapas en uno. Esto se logra usando el método putAll() . Lo llamamos en el primer HashMap , pasamos el segundo como argumento y los elementos del segundo se agregan al primero:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
   HashMap<Integer, String> passportsAndNames2 = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   passportsAndNames2.put(917352, "Clifford Patrick");
   passportsAndNames2.put(925648, "Mitchell Salgado");

   passportsAndNames.putAll(passportsAndNames2);
   System.out.println(passportsAndNames);
}

Salida: {917352=Clifford Patrick, 212133=Bridget Logan, 8082771=Donald John Trump, 925648=Mitchell Salgado, 162348=Iván el Grande} Todos los pares en pasaportesYNombres2 se han copiado en pasaportesYNombres . Ahora considere un ejemplo más complicado. Específicamente, iterando sobre un HashMap en un bucle.

for (Map.Entry<Integer, String> entry: passportsAndNames.entrySet()) {
   System.out.println(entry);
}

La clase Map.Entry denota el par clave-valor dentro del diccionario. El método entrySet() devuelve una lista de todos los pares en nuestro HashMap . Debido a que nuestro mapa consta de estos pares Map.Entry , estamos iterando sobre pares, no sobre claves o valores separados. Salida: 212133=Bridget Logan 8082771=Donald John Trump 162348=Ivan the Great Además, no olvide estudiar la documentación oficial de Oracle para HashMap .