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 can be accessed in their insertion order.
To implement LinkedHashMap API first we create a class “ LinkedHashMapImplmentation” and create all the methods of the LinkedHashMap in this class.
Implementation of the LinkedHashMap API:
Java
// Java program demonstrate LinkedHashMap API import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
class LinkedHashMapImplementation<K, V> {
private LinkedHashMap<K, V> map;
// Constructor creates a new LinkedHashMap
public LinkedHashMapImplementation()
{
map = new LinkedHashMap<K, V>();
}
// Constructor creates a new empty linkedhash map
// according to the given map
public LinkedHashMapImplementation(
Map<? extends K, ? extends V> map1)
{
map = new LinkedHashMap<K, V>(map1);
}
// Delete all the key-value pair
public void clear() { map.clear(); }
// Returns a shallow copy of the LinkedHashMap instance
public Object clone() { return map.clone(); }
// Returns true if the map contains the specified key
public boolean containsKey(Object key)
{
return map.containsKey(key);
}
// Returns true if map contains specified value
public boolean containsValue(Object val)
{
return map.containsValue(val);
}
// Returns a Set view of the mappings
public Set<Map.Entry<K, V> > entrySet()
{
return map.entrySet();
}
// Returns the value to which the specified key is
// mapped, returns null if map does not contains given
// key
public V get(Object key) { return map.get(key); }
// Returns a Set view of the keys
public Set<K> keySet() { return map.keySet(); }
// Associates the specified value with the specified key
// in the map
public V put(K key, V val) { return map.put(key, val); }
// Copies all of the mappings from the specified map to
// the map
public void putAll(Map<? extends K, ? extends V> map1)
{
map.putAll(map1);
}
// Removes the mapping for the key from the
// LinkedHashMap if present
public V remove(Object key) { return map.remove(key); }
// Returns the size of the map
public int size() { return map.size(); }
// Returns a Collection view of the values
public Collection<V> values() { return map.values(); }
} public class GFG {
public static void main(String[] arg)
{
LinkedHashMapImplementation<String, Integer> student
= new LinkedHashMapImplementation<>();
// Add elements to the LinkedHashMap
student.put( "Anuj" , 500 );
student.put( "Ashok" , 460 );
student.put( "Aakansha" , 495 );
// Print the size of the LinkedHashMap
System.out.println( "Size of the LinkedHashMap: "
+ student.size());
System.out.println();
System.out.println(
"The key value pairs of LinkedHashMap:" );
// Print the key value pairs of LinkedHashMap
for (Map.Entry<String, Integer> entry :
student.entrySet()) {
System.out.println(entry.getKey() + " : "
+ entry.getValue());
}
System.out.println();
// Print LinkedHashMap contains key Aakansha or not
System.out.println(
"LinkedHashMap contains Aakansha: "
+ student.containsKey( "Aakansha" ));
System.out.println();
// Print LinkedHashMap contains value 450 or not
System.out.println( "LinkedHashMap contains 450: "
+ student.containsValue( 450 ));
System.out.println();
// Deletes all the entry
student.clear();
System.out.println( "Size of the LinkedHashMap: "
+ student.size());
}
} |
Output
Size of the LinkedHashMap: 3 The key value pairs of LinkedHashMap: Anuj : 500 Ashok : 460 Aakansha : 495 LinkedHashMap contains Aakansha: true LinkedHashMap contains 450: false Size of the LinkedHashMap: 0