Java Program to Implement WeakHashMap API
Last Updated :
21 Jun, 2022
The WeakHashMap class is part of the Java Collections Framework, implementing the Map interface and extending the AbstractMap class. The Map interface helps us map key to values, while the AbstractMap class makes implementing the Map interface easier.
Every key in a map must be unique and can unite with a maximum of one value. Do note that a map itself cannot be a key. The order of key-value pairs is not guaranteed in a WeakHashMap. What makes WeakHashMap different from a regular HashMap is that a WeakHashMap uses weak keys.
Strong Reference: A Strong reference is the type of reference that is generally used. The garbage collector does not reclaim objects having a strong reference.
Example:
Geek strongRef=new Geek();
Weak Reference: If an object does not have a strong or a soft reference, the object is said to have a weak reference.
Example:
new Geek();
An explicit weak reference can also be generated using the WeakReference class
Example:
WeakReference<Geek> weakRef=new WeakReference(new Geek());
// Now use the get() method to obtain the object
// weakRef.get()
The Presence of weak keys means the garbage collector will remove the keys once they are no longer in usage. On the other hand, the values are held by Strong references. So the value objects must not refer directly to their key else; this will prevent the key from being reclaimed. WeakHashMap supports null keys as well as values.
Load factor: The percentage of occupancy after which the capacity of WeakHashMap gets doubled. E.g. If the initial capacity is 16 and the load factor is 0.75 (75%) i.e. 12., then on the addition of the 13th element the size of WeakHashMap gets doubled.
Constructors: The WeakHashMap class provides 4 constructors:
1.WeakHashMap(): This will generate a WeakHashMap object with an initial capacity of 16 and a load factor of 0.75
Syntax:
WeakHashMap<K,V> wHM=new WeakHashMap<K,V>();
2.WeakHashMap(int InitialCapacity): This will generate a WeakHashMap object with the desired InitialCapacity and a load factor of 0.75
Syntax:
WeakHashMap<K,V> wHM=new WeakHashMap<K,V>(20);
// This will generate a WeakHashMap
// object with an initial capacity of 20
3.WeakHashMap(int InitialCapacity, float LoadFactor): This will generate a WeakHashMap object with the desired InitialCapacity as well as load factor.
Syntax:
WeakHashMap<K,V> wHM=new WeakHashMap<K,V>(20,0.9);
// This will generate a WeakHashMap object with an
// initial capacity of 20 and load factor of 90%
4.WeakHashMap(Map map): This will generate a WeakHashMap object and will copy all the key-value pairs from the specified map in the process.
Syntax:
WeakHashMap<K,V> wHM=new WeakHashMap<K,V>( oldMap);
// This will generate a WeakHashMap object and
// will copy all the mappings of oldMap
Operations on WeakHashMap
The operations of WeakHashMap can be classified as either destructive or non-destructive. Destructive methods modify the map on which they operate.
Destructive Operations
1. Addition or Updation
When a key is inserted into the WeakHashMap, the following process occurs internally:
- A unique hash-code is generated for that particular key
- This hash-code is used to generate an index value
- The key-value pair gets stored at that particular index in the hash table
A) public T put(K key, T value): Inserts the given key-value pair in the WeakHashMap. If the key already exists then the value gets updated. This method returns the previous value for the key. If either the key is being inserted for the first time or the previous value is null then null is returned
B) public void putAll(Map m): Inserts all the mapping from map into the current map. If any keys are common then the value gets updated. If the map m specified is null then a NullPointerException is thrown.
2. Deletion
A) public void clear(): Removes all the mappings from the map
B) public T remove(Object key): Removes the mapping associated with the key obj from the map given that it exists. This method will return the value associated with the key being removed. Null will be returned either if no such key exists or if the value itself is null.
Non-Destructive Operations
Non-Destructive methods do not change the map on which they operate. The Non-Destructive methods are as follows:
1. containsKey: Returns true if the map contains the specified key, else returns false.
public boolean containsKey(Object Key)
2. containsValue: Returns true if the map contains a key with the specified value, else returns false.
public boolean containsValue(Object Value)
3. get: Returns the value attached with the specified key. null is returned either if the key doesn’t exist or if the value itself is null.
public T get(Object Key)
4. size: Returns the number of key-value pairs present in the map at the instant when the method is called.
public int size()
5. isEmpty: Returns true if no key-value pairs are present in the map at the instant when the method is called, else returns false.
public boolean isEmpty()
6. entrySet: A key-value pair is also known as a map entry. The Map.Entry interface allows us to work with map entries. entrySet method will return a set of all the present map entries.
public Set<Map.Entry<K,V>> entrySet()
7. keySet: Returns a set containing all the keys present in the map. The changes made in the map are reflected in this set. Conducting operations on the map and traversing the set at the same time may result in undefined behavior.
public Set<k> keySet()
8. values: Returns a Collection view of all the values present in the map. The changes made in the map are reflected in this collection. Conducting operations on the map and traversing the collection at the same time may result in undefined behavior.
public Collection<V> values()
Implementing WeakHashMap
The following program contains the WHI class, which implements the WeakHashMap API. This implementation is then used here to map grades to scores.
Java
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
class WHI<K, V> {
private WeakHashMap<K, V> obj;
public WHI() { obj = new WeakHashMap<K, V>(); }
public WHI(int initialCapacity)
{
obj = new WeakHashMap<K, V>(initialCapacity);
}
public WHI(int initialCapacity, float loadFactor)
{
obj = new WeakHashMap<K, V>(initialCapacity,
loadFactor);
}
public V put(K key, V value)
{
return obj.put(key, value);
}
public void putAll(Map<K, V> map) { obj.putAll(map); }
public void clear() { obj.clear(); }
public V remove(Object key) { return obj.remove(key); }
public boolean containsKey(Object key)
{
return obj.containsKey(key);
}
public boolean containsValue(Object value)
{
return obj.containsValue(value);
}
public V get(Object key) { return obj.get(key); }
public int size() { return obj.size(); }
public boolean isEmpty() { return obj.isEmpty(); }
public Set<Map.Entry<K, V> > entrySet()
{
return obj.entrySet();
}
public Set<K> keySet() { return obj.keySet(); }
public Collection<V> values() { return obj.values(); }
}
public class Main {
public static void main(String args[])
{
WHI<String, Integer> obj1
= new WHI<String, Integer>();
System.out.println(
"The grades and cut off are as follows: ");
obj1.put("A+", 90);
obj1.put("A", 80);
obj1.put("B", 70);
obj1.put("C", 60);
for (Map.Entry<String, Integer> ivar :
obj1.entrySet()) {
System.out.println(ivar.getKey() + " "
+ ivar.getValue());
}
System.out.println("The cut-off for B grade is "
+ obj1.get("B"));
}
}
|
Output
The grades and cut off are as follows:
A+ 90
C 60
B 70
A 80
The cut-off for B grade is 70
Note: The grades and cut off might get printed in an unorderly manner. This is because the order is not guaranteed in a WeakHashMap.
Similar Reads
Java Program to Implement HashMap API
HashMap<K, V> is a part of Java’s collection since Java 1.2. This class is found in java.util package. It provides the basic implementation of the Map interface of Java. It stores the data in (Key, Value) pairs, and you can access them by an index of another type (e.g. an Integer). One object
4 min read
Java Program to Implement HashSet API
The HashSet class implements the Set interface, backed by a hash table which is actually a HashMap instance. No guarantee is made as to the iteration order of the set which means that the class does not guarantee the constant order of elements over time. This class permits the null element. The clas
4 min read
Java Program to Implement HashTable API
The Hashtable class implements a hash table, which maps keys to values. Any non-null object can be used as a key or as a value. To successfully store and retrieve objects from a hashtable, the objects used as keys must implement the hashCode method and the equals method. To implement Hashtable API f
4 min read
Java Program to Implement SimpleBindings API
SimpleBindings is an implementation of bindings that are supported by HashMap or any other map which is specified by the programmer. Constructors of SimpleBindings API: SimpleBindings(): It is a default constructor that uses a HashMap to store the values.SimpleBindings(Map<String, object> m):
4 min read
Java Program to Implement LinkedHashMap API
The LinkedHashMap is just like HashMap with an additional feature of maintaining an order of elements inserted into it. HashMap provided the advantage of quick insertion, search, and deletion but it never maintained the track and order of insertion which the LinkedHashMap provides where the elements
3 min read
Java Program to Implement LinkedHashSet API
The LinkedHashSet is an ordered version of HashSet that maintains a doubly-linked List across all elements. When the iteration order is needed to be maintained, this class is used. When iterating through a HashSet, the order is unpredictable, while a LinkedHashSet lets us iterate through the element
4 min read
Java Program to Implement IdentityHashMap API
The IdentityHashMap implements Map interface using Hashtable, using reference-equality in place of object-equality when comparing keys (and values). This class is not a general-purpose Map implementation. While this class implements the Map interface, it intentionally violates Map’s general contract
6 min read
Java Program to Implement ConcurrentHashMap API
ConcurrentHashMap class obeys the same functional specification as HashTable and includes all the versions of methods corresponding to each method of a HashTable. A HashTable supports the full concurrency of retrievals and adjustable concurrency for updates. All the operations of ConcurrentHashMap a
6 min read
Java Program to Implement Hash Tables with Double Hashing
Double hashing is a technique in an open addressing scheme. and there is the ordinary hash function. In an open addressing scheme, the actual hash function is taking the ordinary hash function when its space is not empty then it will perform another hash function to get some space to insert. Double
10 min read
Java Program to Implement HashTables with Linear Probing
Hashing is a technique that is used to uniquely identify a specific object from a group of similar objects. Suppose an object is to be assigned a key to it to make searching easy. To store the key/value pair, one can use a simple array like a data structure where keys (integers) can be used directly
5 min read