Header Ads Widget

Ticker

6/recent/ticker-posts

Java WeakHashMap

En este tutorial, aprenderemos sobre Java WeakHashMap y sus operaciones. También aprenderemos sobre las diferencias entre WeakHashMap y HashMap con la ayuda de ejemplos.
anuncios a través de carbonoAplicaciones basadas en datos sin la ficha reúnes - ver lo que es posible hoy en día.ANUNCIOS A TRAVÉS DE CARBONO
La WeakHashMapclase del marco de colecciones de Java proporciona la característica de la estructura de datos de la tabla hash.
Implementa la interfaz del mapa .
Java WeakHashMap implementa la interfaz Map.
Nota : Las claves del hashmap débil son del tipo WeakReference .
El objeto de un tipo de referencia débil puede ser recolección de basura en Java si la referencia ya no se usa en el programa.
Aprendamos a crear primero un mapa de hash débil. Luego, aprenderemos cómo se diferencia de un hashmap.

Crear un mapa WeakHash

Para crear un hashmap débil, primero debemos importar el java.util.WeakHashMappaquete. Una vez que importamos el paquete, así es como podemos crear hashmaps débiles en Java.
  1. //WeakHashMap creation with capacity 8 and load factor 0.6
  2. WeakHashMap<Key, Value> numbers = new WeakHashMap<>(8, 0.6);
En el código anterior, hemos creado un hashmap débil 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 WeakHashMap<>(8, 0.6)Aquí, el primer parámetro es la capacidad y el segundo parámetro es loadFactor .
  • capacidad : la capacidad de este mapa es 8. Es decir, puede almacenar 8 entradas.
  • loadFactor : el factor de carga de este mapa 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 débil sin definir su capacidad y factor de carga. Por ejemplo,
  1. // WeakHashMap with default capacity and load factor
  2. WeakHashMap<Key, Value> numbers1 = new WeakHashMap<>();
Por defecto,
  • la capacidad del mapa será de 16
  • el factor de carga será 0.75

Diferencias entre HashMap y WeakHashMap

Veamos la implementación de un hashmap débil en Java.
  1. import java.util.WeakHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating WeakHashMap of numbers
  5. WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
  6. String two = new String("Two");
  7. Integer twoValue = 2;
  8. String four = new String("Four");
  9. Integer fourValue = 4;
  10. // Inserting elements
  11. numbers.put(two, twoValue);
  12. numbers.put(four, fourValue);
  13. System.out.println("WeakHashMap: " + numbers);
  14. // Make the reference null
  15. two = null;
  16. // Perform garbage collection
  17. System.gc();
  18. System.out.println("WeakHashMap after garbage collection: " + numbers);
  19. }
  20. }
Salida
WeakHashMap: {Cuatro = 4, Dos = 2}
WeakHashMap después de la recolección de basura: {Four}
Como podemos ver, cuando la clave dos de un hashmap débil se establece nully realiza la recolección de basura, la clave se elimina.
Esto se debe a que, a diferencia de las claves de hashmaps débiles, son de tipo de referencia débil . Esto significa que el recolector de basura elimina la entrada de un mapa si ya no se usa la clave de esa entrada. Esto es útil para ahorrar recursos.
Ahora veamos la misma implementación en un hashmap.
  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> numbers = new HashMap<>();
  6. String two = new String("Two");
  7. Integer twoValue = 2;
  8. String four = new String("Four");
  9. Integer fourValue = 4;
  10. // Inserting elements
  11. numbers.put(two, twoValue);
  12. numbers.put(four, fourValue);
  13. System.out.println("HashMap: " + numbers);
  14. // Make the reference null
  15. two = null;
  16. // Perform garbage collection
  17. System.gc();
  18. System.out.println("HashMap after garbage collection: " + numbers);
  19. }
  20. }
Salida
HashMap: {Cuatro = 4, Dos = 2}
HashMap después de la recolección de basura: {Cuatro = 4, Dos = 2}
Aquí, cuando la clave dos del hashmap se establece nully realiza la recolección de basura, la clave no se elimina.
Esto se debe a que, a diferencia de los hashmaps débiles, las claves de los hashmaps son de un tipo de referencia fuerte . Esto significa que el recolector de basura no elimina la entrada de un mapa a pesar de que la clave de esa entrada ya no se usa.
Nota : Todas las funcionalidades de los hashmaps y los hashmaps débiles son similares, excepto que las teclas de un hashmap débil son de referencia débil, mientras que las teclas de un hashmap son de fuerte referencia.

Crear WeakHashMap desde otros mapas

Aquí es cómo podemos crear un hashmap débil a partir de otros mapas.
  1. import java.util.HashMap;
  2. import java.util.WeakHashMap;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating a hashmap of even numbers
  6. HashMap<String, Integer> evenNumbers = new HashMap<>();
  7. String two = new String("Two");
  8. Integer twoValue = 2;
  9. evenNumbers.put(two, twoValue);
  10. System.out.println("HashMap: " + evenNumbers);
  11. // Creating a weak hash map from other hashmap
  12. WeakHashMap<String, Integer> numbers = new WeakHashMap<>(evenNumbers);
  13. System.out.println("WeakHashMap: " + numbers);
  14. }
  15. }
Salida
HashMap: {Two = 2}
WeakHashMap: {Two = 2}

Métodos de WeakHashMap

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

Insertar elementos en WeakHashMap

  • 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.WeakHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating WeakHashMap of even numbers
  5. WeakHashMap<String, Integer> evenNumbers = new WeakHashMap<>();
  6. String two = new String("Two");
  7. Integer twoValue = 2;
  8. // Using put()
  9. evenNumbers.put(two, twoValue);
  10. String four = new String("Four");
  11. Integer fourValue = 4;
  12. // Using putIfAbsent()
  13. evenNumbers.putIfAbsent(four, fourValue);
  14. System.out.println("WeakHashMap of even numbers: " + evenNumbers);
  15. //Creating WeakHashMap of numbers
  16. WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
  17. String one = new String("One");
  18. Integer oneValue = 1;
  19. numbers.put(one, oneValue);
  20. // Using putAll()
  21. numbers.putAll(evenNumbers);
  22. System.out.println("WeakHashMap of numbers: " + numbers);
  23. }
  24. }
Salida
WeakHashMap de números pares: {Cuatro = 4, Dos = 2}
WeakHashMapa de números: {Dos = 2, Cuatro = 4, Uno = 1}

Acceder a elementos de WeakHashMap

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.WeakHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating WeakHashMap of even numbers
  5. WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
  6. String one = new String("One");
  7. Integer oneValue = 1;
  8. numbers.put(one, oneValue);
  9. String two = new String("Two");
  10. Integer twoValue = 2;
  11. numbers.put(two, twoValue);
  12. System.out.println("WeakHashMap: " + numbers);
  13. // Using entrySet()
  14. System.out.println("Key/Value mappings: " + numbers.entrySet());
  15. // Using keySet()
  16. System.out.println("Keys: " + numbers.keySet());
  17. // Using values()
  18. System.out.println("Values: " + numbers.values());
  19. }
  20. }
Salida
WeakHashMap: {Two = 2, One = 1}
Asignaciones de clave / valor: [Dos = 2, Uno = 1]
Claves: [dos, uno]
Valores: [1, 2]
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.WeakHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating WeakHashMap of even numbers
  5. WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
  6. String one = new String("One");
  7. Integer oneValue = 1;
  8. numbers.put(one, oneValue);
  9. String two = new String("Two");
  10. Integer twoValue = 2;
  11. numbers.put(two, twoValue);
  12. System.out.println("WeakHashMap: " + numbers);
  13. // Using get()
  14. int value1 = numbers.get("Two");
  15. System.out.println("Using get(): " + value1);
  16. // Using getOrDefault()
  17. int value2 = numbers.getOrDefault("Four", 4);
  18. System.out.println("Using getOrDefault(): " + value2);
  19. }
  20. }
Salida
WeakHashMap: {Two = 2, One = 1}
Usando get (): 2
Usando getOrDefault (): 4

Eliminar elementos WeakHashMap

  • 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.WeakHashMap;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating WeakHashMap of even numbers
  5. WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
  6. String one = new String("One");
  7. Integer oneValue = 1;
  8. numbers.put(one, oneValue);
  9. String two = new String("Two");
  10. Integer twoValue = 2;
  11. numbers.put(two, twoValue);
  12. System.out.println("WeakHashMap: " + numbers);
  13. // Using remove() with single parameter
  14. int value = numbers.remove("Two");
  15. System.out.println("Removed value: " + value);
  16. // Using remove() with 2 parameters
  17. boolean result = numbers.remove("One", 3);
  18. System.out.println("Is the entry {One=3} removed? " + result);
  19. System.out.println("Updated WeakHashMap: " + numbers);
  20. }
  21. }
Salida
WeakHashMap: {Two = 2, One = 1}
Valor eliminado: 2
¿Se ha eliminado la entrada {One = 3}? Falso
WeakHashMap actualizado: {One = 1}

Otros métodos de WeakHashMap

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

Para obtener más información, visite la documentación oficial de Java WeakHashMap .

Publicar un comentario

0 Comentarios