HashMap Vs WeakHashMap in Java

Last Updated: 22 January, 2023

WeakHashMap is almost similar to the HashMap class in Java. The major difference is that an entry in a WeakHashMap will automatically be removed by the garbage collector when its key is no longer in ordinary use.

There are many differences between the HashMap and WeakHashMap that are given below.

👉 HashMap

The HashMap class was introduced in the Java 1.2 version and is available in the java.util package. HashMap is a child class of the AbstractMap class, and it implements the Map interface as well as the Cloneable and Serializable interfaces.

HashMap is used to store the data in the form of key-value pairs, where keys must be unique and values may be duplicated. HashMap accepts only one null key and multiple null values.

👉 WeakHashMap

WeakHashMap is a child class of AbstractMap and implements the Map interface in Java. It was introduced in the JDK 1.2 version and is available in the java.util package, which stores only weak references to its keys.

The keys entered into a WeakHashMap are held using weak references. This allows the garbage collector to collect the keys if there are no other strong references to those keys elsewhere in the application.

👉 HashMap and WeakHashMap have the following differences:

HashMap	WeakHashMap
The stored entry object is not eligible for garbage collection.	An entry in a WeakHashMap will be automatically removed when its key loses all strong and soft references.
HashMap holds strong references to its key objects.	Weak references to keys are stored in the case of a WeakHashMap.
The size() method will always return the same value unless we explicitly add or remove entries.	The size() method may return a smaller value as a few entries might be automatically removed by the GC.
HashMap implements a Serializable interface.	WeakHashMap does not implement the Serializable interface.
The Cloneable interface is implemented by the HashMap, and its clone() method returns a shallow copy of the HashMap.	It does not implement a clonable interface.

HashMap

WeakHashMap

The stored entry object is not eligible for garbage collection.

An entry in a WeakHashMap will be automatically removed when its key loses all strong and soft references.

HashMap holds strong references to its key objects.

Weak references to keys are stored in the case of a WeakHashMap.

The size() method will always return the same value unless we explicitly add or remove entries.

The size() method may return a smaller value as a few entries might be automatically removed by the GC.

HashMap implements a Serializable interface.

WeakHashMap does not implement the Serializable interface.

The Cloneable interface is implemented by the HashMap, and its clone() method returns a shallow copy of the HashMap.

It does not implement a clonable interface.

👉 Example of HashMap and WeakHashMap in Java

Example 1: A sample Java program of HashMap

  
  import java.util.HashMap;
  import java.util.Map;
  public class HashMapExample {
    public static void main(String[] args) {
      // Creating HashMap
      HashMap<String, String> map = new HashMap<>();
        
      // Inserting data in the form of key-value pair using put() method
      map.put("in", "India");
      map.put("us", "United State");
      map.put("en", "England");
      map.put("ca", "Canada");
  
      System.out.println("Iterating Hashmap and printing Key and Value");
      for (Map.Entry m : map.entrySet()) {
        System.out.println(m.getKey() + " - " + m.getValue());
      }
    }
  }

Iterating Hashmap and printing Key and Value
in - India
en - England
us - United State
ca - Canada

Example 2: A sample Java program of WeakHashMap

  
  import java.util.WeakHashMap;
  public class WeakHashMapExample {
    public static void main(String[] args) {
      // Creating a WeakHashMap
      WeakHashMap<Department, Employee> map = new WeakHashMap<>();
  
      Department dep1 = new Department(100);
      Department dep2 = new Department(200);
  
      // Adding data in the form of key-value pair using put() method
      map.put(dep1, new Employee(11, "Ganesh", "Sales"));
      map.put(dep2, new Employee(22, "Ramesh", "Operation"));
  
      System.out.println("WeakHashMap Data Before calling System.gc()");
      map.forEach((k, v) -> System.out.println(
                              k.getDepartmentId() + " => " + v.getEmpId() + ", " 
                              + v.getEmpName() + ", " + v.getDesignation()));
  
      // Setting null reference
      dep1 = null;
      // Calling Garbage Collector
      System.gc();
  
      System.out.println("\nWeakHashMap Data After calling System.gc()");
      map.forEach((k, v) -> System.out.println(
                                k.getDepartmentId() + " => " + v.getEmpId() + ", " 
                                + v.getEmpName() + ", " + v.getDesignation()));
    }
  }
  
  class Employee {
    private Integer empId;
    private String empName;
    private String designation;
  
    public Employee(Integer empId, String empName, String designation) {
      this.empId = empId;
      this.empName = empName;
      this.designation = designation;
    }
  
    // Setter-Getter Methods
  }
  
  class Department {
    private Integer departmentId;
  
    public Department(Integer departmentId) {
      this.departmentId = departmentId;
    }
  
    // Setter-Getter Methods
  }

WeakHashMap Data Before calling System.gc()
100 => 11, Ganesh, Sales
200 => 22, Ramesh, Operation

WeakHashMap Data After calling System.gc()
200 => 22, Ramesh, Operation