Large collections such as HashMap
, ArrayList
, and Set
can hold references to objects even after they are no longer needed. If the objects are strongly referenced inside these collections, they cannot be garbage collected, leading to memory leaks.
1️⃣ The Problem: Strong References in Collections
- If you store objects in a
HashMap
,ArrayList
, or other collections, they are strongly referenced by default. - Even if you set the original reference to
null
, the object remains in the collection, preventing garbage collection.
Example: Memory Leak Due to Strong References
import java.util.HashMap;
import java.util.Map;
public class StrongReferenceCollectionExample {
public static void main(String[] args) {
Map<Object, String> map = new HashMap<>();
Object key = new Object();
map.put(key, "Data");
key = null; // Remove strong reference
System.gc(); // Suggest GC
System.out.println("Map size: " + map.size()); // The key is still in the map!
}
}
Why Does This Cause a Memory Leak?
- Even though
key = null;
, theHashMap
still holds a reference to the object. - The object cannot be garbage collected because the map prevents it from being freed.
2️⃣ The Solution: Using WeakHashMap
A WeakHashMap
automatically removes entries whose keys are only weakly referenced, preventing memory leaks.
Example: Fixing Memory Leak with WeakHashMap
import java.util.WeakHashMap;
public class WeakHashMapExample {
public static void main(String[] args) {
WeakHashMap<Object, String> weakMap = new WeakHashMap<>();
Object key = new Object();
weakMap.put(key, "Cached Data");
key = null; // Remove strong reference
System.gc(); // Suggest GC
System.out.println("Map size: " + weakMap.size()); // Might be 0 if GC removed it
}
}
Why Does This Work?
- Since
WeakHashMap
stores keys as weak references, once the original reference (key
) is removed, the object becomes eligible for GC. - If GC runs, the entry is automatically removed from the map.
- No memory leak! ✅
3️⃣ Using WeakReference
in Large Collections
If you’re using lists or other collections, you can use WeakReference
instead of WeakHashMap
.
Example: Avoiding Memory Leak in List
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
public class WeakReferenceListExample {
public static void main(String[] args) {
List<WeakReference<Object>> list = new ArrayList<>();
Object obj = new Object();
list.add(new WeakReference<>(obj));
obj = null; // Remove strong reference
System.gc(); // Suggest GC
list.removeIf(ref -> ref.get() == null); // Clean up collected references
System.out.println("List size: " + list.size()); // Might be 0 if GC ran
}
}
Why Does This Work?
- The list holds
WeakReference<Object>
instead of a strong reference. - When GC runs, the referenced object is removed.
- We clean up null references using
list.removeIf(ref -> ref.get() == null)
.
4️⃣ Summary: How Weak References Prevent Memory Leaks in Large Collections
Collection Type | Problem with Strong References | Solution Using Weak References |
---|---|---|
HashMap<Object, String> | Entries stay in memory even after the key is set to null . | Use WeakHashMap<Object, String> , so keys are collected when unused. |
ArrayList<Object> | Objects in the list prevent GC, causing memory buildup. | Store WeakReference<Object> in the list instead. |
Set<Object> | Objects persist in memory after use. | Use WeakReference to allow GC cleanup. |
5️⃣ Conclusion
- Large collections holding strong references can prevent GC from reclaiming memory.
- Weak references (
WeakHashMap
orWeakReference
) allow GC to remove unused objects. - This helps prevent memory leaks, especially in caching, listener patterns, and large collections.
📌 In short: Weak references allow collections to automatically clean up unused objects, preventing memory leaks! 🚀