ejemplo WeakHashMap

Question

creo un WeakHashMap como

WeakHashMap<Employee,String> map = new WeakHashMap<Employee,String>(); 
map.put(emp,"hello"); 

donde emp es un objeto Employee. Ahora si hago emp = null o dice que el objeto emp ya no se referencia, ¿se eliminará la entrada de WeakHashMap, es decir, el tamaño de Map será cero?
¿Y será viceversa en el caso de HashMap?
¿Es correcto mi entendimiento de WeakHashMap?

Answer 1

me encontré con el código de ejemplo para entender la diferencia entre HashMap y WeakHashMap

  Map hashMap= new HashMap(); 
      Map weakHashMap = new WeakHashMap(); 

      String keyHashMap = new String("keyHashMap"); 
      String keyWeakHashMap = new String("keyWeakHashMap"); 

      hashMap.put(keyHashMap, "helloHash"); 
      weakHashMap.put(keyWeakHashMap, "helloWeakHash"); 
      System.out.println("Before: hash map value:"+hashMap.get("keyHashMap")+" and weak hash map value:"+weakHashMap.get("keyWeakHashMap")); 

      keyHashMap = null; 
      keyWeakHashMap = null; 

      System.gc(); 

      System.out.println("After: hash map value:"+hashMap.get("keyHashMap")+" and weak hash map value:"+weakHashMap.get("keyWeakHashMap")); 

La salida será:

Before: hash map value:helloHash and weak hash map value:helloWeakHash 
After: hash map value:helloHash and weak hash map value:null 

Answer 2

* ¿Se eliminará la entrada del WeakHashMap, es decir, el tamaño de Map será cero? *

Si emp contenía la última referencia haciendo que el Empleado strongly reachable entonces la entrada en el mapa puede ser eliminado.

docs El Java resume bastante bien:

Una aplicación de mapas basados ​​en tabla hash con claves débiles. Una entrada en un WeakHashMap se eliminará automáticamente cuando su clave ya no esté en uso ordinario. Más precisamente, la presencia de un mapeo para una clave dada no impedirá que la clave sea descartada por el recolector de basura [...]. Cuando se descarta una clave, su entrada se elimina efectivamente del mapa, por lo que esta clase se comporta de forma algo diferente a otras implementaciones de Mapas.

 

¿Y será viceversa en caso de HashMap?

La eliminación de la entrada del WeakHashMap no afectará a ninguna otra referencia en el programa.

Answer 3

Un ejemplo muy sencillo, para iluminar a lo que ya se ha dicho:

import java.util.WeakHashMap; 

public class WeakHashMapDemo { 

    public static void main(String[] args) { 
     // -- Fill a weak hash map with one entry 
     WeakHashMap<Data, String> map = new WeakHashMap<Data, String>(); 
     Data someDataObject = new Data("foo"); 
     map.put(someDataObject, someDataObject.value); 
     System.out.println("map contains someDataObject ? " + map.containsKey(someDataObject)); 

     // -- now make someDataObject elligible for garbage collection... 
     someDataObject = null; 

     for (int i = 0; i < 10000; i++) { 
      if (map.size() != 0) { 
       System.out.println("At iteration " + i + " the map still holds the reference on someDataObject"); 
      } else { 
       System.out.println("somDataObject has finally been garbage collected at iteration " + i + ", hence the map is now empty"); 
       break; 
      } 
     } 
    } 

    static class Data { 
     String value; 
     Data(String value) { 
      this.value = value; 
     } 
    } 
} 

Salida:

map contains someDataObject ? true 
    ... 
    At iteration 6216 the map still holds the reference on someDataObject 
    At iteration 6217 the map still holds the reference on someDataObject 
    At iteration 6218 the map still holds the reference on someDataObject 
    somDataObject has finally been garbage collected at iteration 6219, hence the map is now empty 

Answer 4

Las referencias en java son la dirección de memoria donde los objetos creados apuntan en la memoria. En un WeakHashMap, se utiliza el concepto de referencia débil.

Tan pronto como cree un objeto en Java y lo asigne a alguna variable, se volverá muy accesible.

El objeto de referencia débil puede ser algo similar al objeto que no tiene referencias de memoria, es decir, puede ser basura ahora.

Answer 5

En otras implementaciones de Map como HashMap, las claves son muy accesibles.Por ejemplo, si un HashMap tiene claves como clase Person como se muestra a continuación y si el objeto Person se establece en nulo, incluso después de esto si hacemos map.get (Person) obtendremos el valor de la memoria ya que las claves están fuertemente referenciadas en un HashMap.

wm.put(person, person.getFirstName()); 
person = null; 
System.gc(); 
System.out.println("Hash Map :" + wm.toString()); 

Salida: Mapa Hash: {} test.Person@12dacd1=John

En comparación con HashMap, WeakHashMap es la que va a eliminar sus enteries tan pronto como las teclas tienen ninguna referencia en la memoria. Por ejemplo, si un WeakHashMap tiene claves como clase Person como se muestra a continuación y si el objeto Person se establece en nulo, ahora si haces map.get (Person) obtendremos null de él porque la clave no tiene referencia (o más bien débilmente) accesible).

wm.put(person, person.getFirstName()); 
person = null; 
System.gc(); 
System.out.println("Weak Hash Map :" + wm.toString()); 

Salida: Débil Hash Mapa: {}

Answer 6

ejemplo WeakHashMap:

Map map = new WeakHashMap(); 
Foo foo = new Foo(); 
map.put(foo, "bar"); 
foo=null; // strong refrence is removed and object is available for garbage collection. 

ejemplo HashMap:

Map map = new HashMap(); 
Foo foo = new Foo(); 
map.put(foo, "bar"); 
foo=null; // even though the reference is nullified object will not garbage collected because map is having Strong refrence.