public abstract class AbstractMap<K,V> extends Object, implements Map<K,V>

// Java Program to demonstrate adding
// elements to the AbstractMap

import java.util.*;

public class AddElements {

    public static void main(String[] args)
    {
        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();

        // Adding values to the AbstractMap
        // Note that we do not create an object of
        // AbstractMap
        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "an");
        absMap.put(4, "AbstractMap");

        // Displaying the mappings using
        // entrySet() to get the set view
        System.out.println("The Set view of the mappings:");
        System.out.println(absMap.entrySet());
    }
}

The Set view of the mappings:
[1=This, 2=is, 3=an, 4=AbstractMap]

mapName.remove(Object key);

// Java Program to demonstrate removing
// elements from the AbstractMap

import java.util.*;

public class RemoveElements {

    public static void main(String[] args)
    {
        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();

        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "an");
        absMap.put(4, "AbstractMap");

        // Displaying the mappings
        System.out.println("Mappings of the AbstractMap:");
        System.out.println(absMap);

        // Removing an entry using the remove() method
        absMap.remove(1);

        // Displaying the mappings
        System.out.println("Mappings of the AbstractMap:");
        System.out.println(absMap);

        // Clearing the whole map using clear()
        absMap.clear();

        // Displaying the mappings
        System.out.println("\nThe Set view of the mappings:");
        System.out.println(absMap);
    }
}

Mappings of the AbstractMap:
{1=This, 2=is, 3=an, 4=AbstractMap}
Mappings of the AbstractMap:
{2=is, 3=an, 4=AbstractMap}

The Set view of the mappings:
{}

// Java Program to demonstrate replacing
// elements of AbstractMap

import java.util.AbstractMap;
import java.util.HashMap;

public class ReplaceElements {

    public static void main(String[] args)
    {

        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();

        // Adding values to the AbstractMap
        // Note that we do not create an object of
        // AbstractMap
        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "a");
        absMap.put(4, "AbstractMap");

        // Displaying the mappings
        System.out.println("Mappings of the AbstractMap:");
        System.out.println(absMap);

        // Replacing the mapping associated to 3
        absMap.replace(3, "an");

        // Displaying the mappings
        System.out.println("\nMappings of the AbstractMap:");
        System.out.println(absMap);
    }
}

Mappings of the AbstractMap:
{1=This, 2=is, 3=a, 4=AbstractMap}

Mappings of the AbstractMap:
{1=This, 2=is, 3=an, 4=AbstractMap}

// Java Program to demonstrate
// traversing AbstractMap

import java.util.*;

public class Traversing {

    public static void main(String[] args)
    {
        // Since AbstractMap is an abstract class
        // create object using HashMap
        AbstractMap<Integer, String> absMap
            = new HashMap<Integer, String>();

        // Adding values to the AbstractMap
        // Note that we do not create an object of
        // AbstractMap
        absMap.put(1, "This");
        absMap.put(2, "is");
        absMap.put(3, "a");
        absMap.put(4, "AbstractMap");

        // METHOD 1
        // Iterate over the map using entrySet()
        // which returns a collection view of the map

        System.out.println("Using the entrySet() method");

        for (AbstractMap.Entry<Integer, String> entry :
             absMap.entrySet()) {
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }

        // METHOD 2
        // Iterate over the map using the Iterator interface

        System.out.println(
            "\nUsing the Iterator interface");

        Iterator<Integer> itr = absMap.keySet().iterator();
        while (itr.hasNext()) {
            int key = itr.next();
            System.out.println("Key = " + key
                               + ", Value =  "
                               + absMap.get(key));
        }
    }
}

Using the entrySet() method
Key = 1, Value = This
Key = 2, Value = is
Key = 3, Value = a
Key = 4, Value = AbstractMap

Using the Iterator interface
Key = 1, Value =  This
Key = 2, Value =  is
Key = 3, Value =  a
Key = 4, Value =  AbstractMap

HashMap< ? , ? > hmName = new HashMap< ? , ? >();

IdentityHashMap< ? , ? > ihmName = new IdentityHashMap< ? , ? >();

WeakHashMap< ? , ? > whmName = new WeakHashMap< ? , ? >();

TreeMap< ? , ? > tmName = new TreeMap< ? , ? >();

EnumMap< enumName, ? > emName = new EnumMap< enumName, ? >();

ConcurrentHashMap< ? , ? > chmName = new ConcurrentHashMap< ? , ? >();

ConcurrentSkipListMap< ? , ? > cslmName = new ConcurrentSkipListMap< ? , ? >();