Breaking

Post Top Ad

Your Ad Spot

sábado, 21 de diciembre de 2019

Java HashMap

En este tutorial, aprenderemos sobre la clase Java HashMap y sus métodos con la ayuda de ejemplos.
anuncios a través de carbonoLanza el software de gestión que tus ingenieros adorarán. Gratis para equipos pequeños.ANUNCIOS A TRAVÉS DE CARBONO
La HashMapclase del marco de colecciones de Java proporciona la implementación de la tabla hash de la interfaz Map .

Crea un HashMap

Para crear un mapa hash, java.util.HashMapprimero debemos importar el paquete. Una vez que importamos el paquete, así es como podemos crear hashmaps en Java.
  1. // HashMap creation with 8 capacity and 0.6 load factor
  2. HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);
En el código anterior, hemos creado un hashmap llamado números .
Aquí,
  • Clave : un identificador único utilizado para asociar cada elemento (valor) en un mapa
  • Valor : elementos asociados por claves en un mapa
Fíjate en la parte new HashMap<>(8, 0.6)Aquí, el primer parámetro es la capacidad y el segundo parámetro es loadFactor .
  • capacidad : la capacidad de este mapa hash es 8. Es decir, puede almacenar 8 entradas.
  • loadFactor : el factor de carga de este mapa hash es 0.6. Esto significa que cada vez que nuestra tabla hash se llena en un 60%, las entradas se mueven a una nueva tabla hash del doble del tamaño de la tabla hash original.
Capacidad predeterminada y factor de carga
Es posible crear un hashmap sin definir su capacidad y factor de carga. Por ejemplo,
  1. // HashMap with default capacity and load factor
  2. HashMap<Key, Value> numbers1 = new HashMap<>();
Por defecto,
  • la capacidad del mapa hash será de 16
  • el factor de carga será 0.75

Crear HashMap desde otros mapas

Aquí es cómo podemos crear un hashmap que contenga todos los elementos de otros mapas.
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating a hashmap of even numbers
  5. HashMap<String, Integer> evenNumbers = new HashMap<>();
  6. evenNumbers.put("Two", 2);
  7. evenNumbers.put("Four", 4);
  8. System.out.println("HashMap1: " + evenNumbers);
  9. // Creating a hash map from other hashmap
  10. HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
  11. numbers.put("Three", 3);
  12. System.out.println("HashMap2: " + numbers);
  13. }
  14. }
Salida
HashMap1: {Cuatro = 4, Dos = 2}
HashMap2: {Dos = 2, Tres = 3, Cuatro = 4}

Métodos de HashMap

La HashMapclase proporciona varios métodos que nos permiten realizar varias operaciones en el mapa.

Insertar elementos en HashMap

  • put() - inserta la asignación de clave / valor especificada en el mapa
  • putAll() - inserta todas las entradas del mapa especificado en este mapa
  • putIfAbsent() - inserta la asignación de clave / valor especificada en el mapa si la clave especificada no está presente en el mapa
Por ejemplo,
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating HashMap of even numbers
  5. HashMap<String, Integer> evenNumbers = new HashMap<>();
  6. // Using put()
  7. evenNumbers.put("Two", 2);
  8. evenNumbers.put("Four", 4);
  9. // Using putIfAbsent()
  10. evenNumbers.putIfAbsent("Six", 6);
  11. System.out.println("HashMap of even numbers: " + evenNumbers);
  12. //Creating HashMap of numbers
  13. HashMap<String, Integer> numbers = new HashMap<>();
  14. numbers.put("One", 1);
  15. // Using putAll()
  16. numbers.putAll(evenNumbers);
  17. System.out.println("HashMap of numbers: " + numbers);
  18. }
  19. }
Salida
HashMap de números pares: {Seis = 6, Cuatro = 4, Dos = 2}
HashMap de números: {Seis = 6, Uno = 1, Cuatro = 4, Dos = 2}

Acceder a elementos HashMap

1. Usando entrySet (), keySet () y values ​​()
  • entrySet() - devuelve un conjunto de todas las asignaciones de clave / valor del mapa
  • keySet() - devuelve un conjunto de todas las teclas del mapa
  • values() - devuelve un conjunto de todos los valores del mapa
Por ejemplo,
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. HashMap<String, Integer> numbers = new HashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("HashMap: " + numbers);
  9. // Using entrySet()
  10. System.out.println("Key/Value mappings: " + numbers.entrySet());
  11. // Using keySet()
  12. System.out.println("Keys: " + numbers.keySet());
  13. // Using values()
  14. System.out.println("Values: " + numbers.values());
  15. }
  16. }
Salida
HashMap: {Uno = 1, Dos = 2, Tres = 3}
Asignaciones de clave / valor: [Uno = 1, Dos = 2, Tres = 3]
Claves: [Uno, Dos, Tres]
Valores: [1, 2, 3]
2. Usando get () y getOrDefault ()
  • get()- Devuelve el valor asociado con la clave especificada. Devuelve nullsi no se encuentra la clave.
  • getOrDefault()- Devuelve el valor asociado con la clave especificada. Devuelve el valor predeterminado especificado si no se encuentra la clave.
Por ejemplo,
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. HashMap<String, Integer> numbers = new HashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("HashMap: " + numbers);
  9. // Using get()
  10. int value1 = numbers.get("Three");
  11. System.out.println("Returned Number: " + value1);
  12. // Using getOrDefault()
  13. int value2 = numbers.getOrDefault("Five", 5);
  14. System.out.println("Returned Number: " + value2);
  15. }
  16. }
Salida
HashMap: {Uno = 1, Dos = 2, Tres = 3}
Número devuelto: 3
Número devuelto: 5

Eliminar elementos

  • remove(key) - devuelve y elimina la entrada asociada con la clave especificada del mapa
  • remove(key, value) - elimina la entrada del mapa solo si la clave especificada se asigna al valor especificado y devuelve un valor booleano
Por ejemplo,
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. HashMap<String, Integer> numbers = new HashMap<>();
  5. numbers.put("One", 1);
  6. numbers.put("Two", 2);
  7. numbers.put("Three", 3);
  8. System.out.println("HashMap: " + numbers);
  9. // remove method with single parameter
  10. int value = numbers.remove("Two");
  11. System.out.println("Removed value: " + value);
  12. // remove method with two parameters
  13. boolean result = numbers.remove("Three", 3);
  14. System.out.println("Is the entry Three removed? " + result);
  15. System.out.println("Updated HashMap: " + numbers);
  16. }
  17. }
Salida
HashMap: {Uno = 1, Dos = 2, Tres = 3}
Valor eliminado: 2
¿Se ha eliminado la entrada Tres? Cierto
HashMap actualizado: {One = 1}

Reemplazar elementos

  • replace(key, value)- reemplaza el valor asociado con la clave especificada por un nuevo valor
  • replace(key, old, new)- reemplaza el antiguo valor con el nuevo valor sólo si viejo valor ya está asociada a la especificada clave
  • replaceAll(function)- reemplaza cada valor del mapa con el resultado de la función especificada
Por ejemplo,
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. HashMap<String, Integer> numbers = new HashMap<>();
  5. numbers.put("First", 1);
  6. numbers.put("Second", 2);
  7. numbers.put("Third", 3);
  8. System.out.println("Original HashMap: " + numbers);
  9. // Using replace()
  10. numbers.replace("Second", 22);
  11. numbers.replace("Third", 3, 33);
  12. System.out.println("HashMap using replace(): " + numbers);
  13. // Using replaceAll()
  14. numbers.replaceAll((key, oldValue) -> oldValue + 2);
  15. System.out.println("HashMap using replaceAll(): " + numbers);
  16. }
  17. }
Salida
HashMap original: {Uno = 1, Dos = 2, Tres = 3}
HashMap usando reemplazar: {Uno = 1, Dos = 22, Tres = 33}
HashMap usando replaceAll: {One = 2, Two = 24, Three = 35}
En el programa anterior, observe la declaración
  1. numbers.replaceAll((key, oldValue) -> oldValue + 2);
Aquí, el método accede a todas las entradas del mapa. Luego reemplaza todos los valores con los nuevos valores proporcionados por la expresión lambda .

Calcular valores

1. Usando el método compute ()
  • compute()- Calcula un nuevo valor utilizando la función especificada. Luego asocia el valor calculado a la clave especificada.
  • computeIfAbsent()- Si la clave especificada no se asigna a ningún valor, el método calculará un nuevo valor utilizando la función especificada. Luego asocia el nuevo valor con la clave.
  • computeIfPresent()- Si la clave especificada ya está asignada a algún valor, este método calculará un nuevo valor utilizando la función especificada. Luego asocia el nuevo valor con la clave.
Por ejemplo,
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. HashMap<String, Integer> numbers = new HashMap<>();
  5. numbers.put("First", 1);
  6. numbers.put("Second", 2);
  7. System.out.println("Original HashMap: " + numbers);
  8. // Using compute()
  9. numbers.compute("First", (key, oldValue) -> oldValue + 2);
  10. numbers.compute("Second", (key, oldValue) -> oldValue + 1);
  11. System.out.println("HashMap using compute(): " + numbers);
  12. // Using computeIfAbsent()
  13. numbers.computeIfAbsent("Three", key -> 5);
  14. System.out.println("HashMap using computeIfAbsent(): " + numbers);
  15. // Using computeIfPresent()
  16. numbers.computeIfPresent("Second", (key, oldValue) -> oldValue * 2);
  17. System.out.println("HashMap using computeIfPresent(): " + numbers);
  18. }
  19. }
Salida
HashMap original: {Segundo = 2, Primero = 1}
HashMap usando compute (): {Segundo = 5, Primero = 3}
HashMap usando computeIfAbsent (): {Segundo = 5 Primero = 3, Tres = 8}
HashMap usando computeIfPresent (): {Segundo = 10, Primero = 3, tres = 8
En el ejemplo anterior, hemos recalculado los valores del mapa utilizando el compute()método
Aquí, hemos usado expresiones lambda como argumentos de método para recalcular los valores.

2. Usando el método merge ()
El merge()método asocia el valor especificado a la clave especificada si la clave especificada aún no está asociada.
Sin embargo, si la clave especificada ya está asociada con un valor, fusionará el nuevo valor especificado con el valor anterior existente. Por ejemplo,
  1. import java.util.HashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. HashMap<String, Integer> numbers = new HashMap<>();
  5. numbers.put("First", 1);
  6. numbers.put("Second", 2);
  7. System.out.println("Original HashMap: " + numbers);
  8. // Using merge() Method
  9. numbers.merge("First", 4, (oldValue, newValue) -> oldValue + newValue);
  10. System.out.println("New HashMap: " + numbers);
  11. }
  12. }
Salida
HashMap original: {Segundo = 2, Primero = 1}
Nuevo HashMap: {Segundo = 2, Primero = 5}
En el ejemplo anterior, el merge()método toma 3 parámetros: clave , newValue y una expresión lambda (que calcula el nuevo valor combinado).

Otros métodos de HashMap

MétodoDescripción
clear()Elimina todas las entradas del mapa.
containsKey()Comprueba si el mapa contiene la clave especificada y devuelve un valor booleano
containsValue()Comprueba si el mapa contiene el valor especificado y devuelve un valor booleano
size()Devuelve el tamaño del mapa.
isEmpty()Comprueba si el mapa está vacío y devuelve un valor booleano

Iterar a través de un HashMap

En a HashMap, podemos
  • iterar a través de sus teclas
  • iterar a través de sus valores
  • iterar a través de sus claves / valores

1. Usando el bucle forEach
  1. import java.util.HashMap;
  2. import java.util.Map.Entry;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating a HashMap
  6. HashMap<String, Integer> numbers = new HashMap<>();
  7. numbers.put("One", 1);
  8. numbers.put("Two", 2);
  9. numbers.put("Three", 3);
  10. System.out.println("HashMap: " + numbers);
  11. // Accessing the key/value pair
  12. System.out.print("Entries: ");
  13. for(Entry<String, Integer> entry: numbers.entrySet()) {
  14. System.out.print(entry);
  15. System.out.print(", ");
  16. }
  17. // Accessing the key
  18. System.out.print("\nKeys: ");
  19. for(String key: numbers.keySet()) {
  20. System.out.print(key);
  21. System.out.print(", ");
  22. }
  23. // Accessing the value
  24. System.out.print("\nValues: ");
  25. for(Integer value: numbers.values()) {
  26. System.out.print(value);
  27. System.out.print(", ");
  28. }
  29. }
  30. }
Salida
HashMap: {Uno = 1, Dos = 2, Tres = 3}
Entradas: Uno = 1, Dos = 2, Tres = 3
Claves: uno, dos, tres,
Valores: 1, 2, 3,
En el programa anterior, tenga en cuenta que hemos importado el java.util.Map.Entrypaquete. Aquí Map.Entryestá la clase anidada de la Mapinterfaz.
Esta clase anidada devuelve una vista (elementos) del mapa.

2. Usando el método iterator ()
También es posible iterar HashMapusando el iterator()método. Para utilizar este método, debemos importar el java.util.Iteratorpaquete.
  1. import java.util.HashMap;
  2. import java.util.Iterator;
  3. import java.util.Map.Entry;
  4. class Main {
  5. public static void main(String[] args) {
  6. // Creating a HashMap
  7. HashMap<String, Integer> numbers = new HashMap<>();
  8. numbers.put("One", 1);
  9. numbers.put("Two", 2);
  10. numbers.put("Three", 3);
  11. System.out.println("HashMap: " + numbers);
  12. // Creating an object of Iterator
  13. Iterator<Entry<String, Integer>> iterate1 = numbers.entrySet().iterator();
  14. // Accessing the Key/Value pair
  15. System.out.print("Entries: ");
  16. while(iterate1.hasNext()) {
  17. System.out.print(iterate1.next());
  18. System.out.print(", ");
  19. }
  20. // Accessing the key
  21. Iterator<String> iterate2 = numbers.keySet().iterator();
  22. System.out.print("\nKeys: ");
  23. while(iterate2.hasNext()) {
  24. System.out.print(iterate2.next());
  25. System.out.print(", ");
  26. }
  27. // Accessing the value
  28. Iterator<Integer> iterate3 = numbers.values().iterator();
  29. System.out.print("\nValues: ");
  30. while(iterate3.hasNext()) {
  31. System.out.print(iterate3.next());
  32. System.out.print(", ");
  33. }
  34. }
  35. }
Salida
HashMap: {Uno = 1, Dos = 2, Tres = 3}
Entradas: Uno = 1, Dos = 2, Tres = 3
Claves: uno, dos, tres,
Valores: 1, 2, 3,
En el programa anterior, tenga en cuenta que hemos importado el java.util.Map.Entrypaquete. Aquí Map.Entryestá la clase anidada de la Mapinterfaz.
Esta clase anidada devuelve una vista (elementos) del mapa.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas