Skip to content
Related Articles

Related Articles

Java Program to Implement LinkedHashMap API
  • Last Updated : 28 Jan, 2021

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

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :