wake-up-neo.com

WeakHashMap Beispiel

Ich erstelle eine WeakHashMap als

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

wobei emp ein Employee-Objekt ist. Wenn ich nun emp = null tue oder sage, dass emp-Objekt nicht mehr referenziert wird, wird der Eintrag aus der WeakHashMap entfernt, d. H. Wird die Größe der Map Null sein?
Und wird es bei HashMap umgekehrt sein?
Ist mein Verständnis von WeakHashMap korrekt?

19
Anand

Ich habe den Beispielcode ausgeführt, um den Unterschied zwischen HashMap und WeakHashMap zu verstehen.

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

Die Ausgabe wird sein:

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

Ein sehr einfaches Beispiel, um das bereits Gesagte aufzuklären:

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

Ausgabe :

    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
38
Yanflea

* Wird der Eintrag von der WeakHashMap entfernt, d. h. wird die Größe der Map Null sein? *

Wenn emp die letzte Referenz enthielt, die den Mitarbeiter stark erreichbar macht, dann wird der Eintrag in der Karte möglicherweise entfernt.

Die Java-Dokumentation fasst es ziemlich gut zusammen:

Eine Hashtable-basierte Map-Implementierung mit schwachen Schlüsseln. Ein Eintrag in einer WeakHashMap wird automatisch entfernt, wenn sein Schlüssel nicht mehr normal verwendet wird. Genauer gesagt wird das Vorhandensein einer Zuordnung für einen bestimmten Schlüssel nicht verhindern, dass der Schlüssel vom [...] Garbage Collector verworfen wird. Wenn ein Schlüssel verworfen wurde, wird sein Eintrag effektiv von der Karte entfernt, sodass sich diese Klasse etwas anders verhält als andere Kartenimplementierungen.

Und wird es bei HashMap umgekehrt sein?

Das Entfernen des Eintrags aus der WeakHashMap hat keine Auswirkungen auf andere Verweise im Programm.

6
aioobe

Referenz in Java sind Speicheradressen, auf die die erstellten Objekte im Speicher verweisen. In einer WeakHashMap wird das Konzept der schwachen Referenz verwendet.

Sobald Sie ein Objekt in Java erstellen und es einer Variablen zuweisen, ist es stark erreichbar.

Ein schwaches Referenzobjekt kann einem Objekt ähnlich sein, das keine Speicherreferenzen hat, d. H., Es kann jetzt Müll gesammelt werden.

1
Kumar Bhatia

In anderen Map-Implementierungen wie einer HashMap sind die Schlüssel stark erreichbar. Wenn beispielsweise eine HashMap wie unten gezeigt Schlüssel als Personenklasse hat und das Objekt Person auf null gesetzt ist, erhalten wir den Wert auch dann aus dem Speicher, wenn map.get (Person) ausgeführt wird, da die Schlüssel stark referenziert sind in einer HashMap.

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

Ausgabe: Hash-Map: {[email protected]=John}

Im Vergleich zu HashMap wird WeakHashMap die Eingaben entfernen, sobald die Schlüssel keine Referenz im Speicher haben. Wenn eine WeakHashMap beispielsweise Schlüssel als Personenklasse hat, wie unten gezeigt, und wenn das Person-Objekt auf null gesetzt ist, erhalten wir jetzt, wenn Sie map.get (Person) ausführen, null daraus, weil der Schlüssel keine Referenz hat (oder eher schwach) erreichbar).

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

Ausgabe: Schwache Hash-Map: {}

1
Deepa Bhatia

WeakHashMap Beispiel:

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.  

HashMap-Beispiel:

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.
0
Premraj