ConcurrentHashMap in Java

// Java Program to demosntrates the 
// working of ConcurrentHashMap
import java.util.concurrent.ConcurrentHashMap;
public class Geeks {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // Adding elements to the map
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);

        System.out.println("Map size: " + map.size());

        // Getting values from the map
        System.out.println("Value of A: " + map.get("A"));

        // Removing elements from the map
        map.remove("B");
        System.out.println("After removal map size is: " + map.size());
    }
}

// Java program to demonstrate working of various methods
// like put(), putIfAbsent(), remove() and replace()
import java.util.concurrent.*;
class Geeks {

    public static void main(String[] args)
    {
        // create an instance of
        // ConcurrentHashMap
        ConcurrentHashMap<Integer, String> m
            = new ConcurrentHashMap<>();

        // Insert mappings using
        // put method
        m.put(100, "Hello");
        m.put(101, "Geeks");
        m.put(102, "Geeks");

        // Here we cant add Hello because 101 key
        // is already present in ConcurrentHashMap object
        m.putIfAbsent(101, "Hello");

        // We can remove entry because 101 key
        // is associated with For value
        m.remove(101, "Geeks");

        // Now we can add Hello
        m.putIfAbsent(103, "Hello");

        // We cant replace Hello with For
        m.replace(101, "Hello", "For");
        System.out.println(m);
    }
}

// Java Program to demonstrates 
// the working of put()
import java.util.concurrent.*;
public class Geeks{

    public static void main(String[] args) {
        // Create ConcurrentHashMap
        ConcurrentHashMap<String, String> map1 = new ConcurrentHashMap<>();

        // Add elements to map
        map1.put("1", "One");
        map1.put("2", "Two");
        map1.put("3", "Three");
        map1.put("4", "Four");
        map1.put("5", "Five");
        map1.put("6", "Six");

        // Print map1
        System.out.println("map1: " + map1);

        // Create a new map and copy all entries from map1
        ConcurrentHashMap<String, String> map2 = new ConcurrentHashMap<>(map1);

        // Print map2
        System.out.println("map2: " + map2);
    }
}

// Java program to demonstrate removing
// elements from ConcurrentHashMap
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class Geeks{

    public static void main(String[] args)
    {
        // Creating ConcurrentHashMap
        Map<String, String> m
                = new ConcurrentHashMap<String, String>();

        // Adding elements to the map
        // using put() method
        m.put("1", "One");
        m.put("2", "Two");
        m.put("3", "Three");
        m.put("4", "Four");
        m.put("5", "Five");
        m.put("6", "Six");

        System.out.println("Map: " + m);
        System.out.println();

        // Removing the mapping
        // with existing key 6
        // using remove() method
        String s = m.remove("6");

        // Printing the map after remove()
        System.out.println(
                "After removing mapping with key 6:");
        System.out.println("Map: " + m);
        System.out.println("Value removed: "
                + s);
        System.out.println();

        // Removing the mapping
        // with non-existing key 10
        // using remove() method
        s = m.remove("10");

        // Printing the map after remove()
        System.out.println(
                "After removing mapping with key 10:");
        System.out.println("Map: " + m);
        System.out.println("Value removed: "
                + s);
        System.out.println();

        // Now clear the map using clear()
        m.clear();

        System.out.println("Map after use of clear(): "
                + m);
    }
}

// Java Program Demonstrate accessing
// elements of ConcurrentHashMap
import java.util.concurrent.*;
class Geeks {
    public static void main(String[] args)
    {

        // create an instance of ConcurrentHashMap
        ConcurrentHashMap<Integer, String> m
                = new ConcurrentHashMap<Integer, String>();

        // insert mappings using put method
        m.put(100, "Geeks");
        m.put(101, "for");
        m.put(102, "Geeks");
        m.put(103, "Contribute");

        // Displaying the HashMap

        System.out.println("ConcurrentHashMap:" + m);

        // Display the value of 100
        System.out.println("The Value associated to "
                + "100 is : " + m.get(100));

        // Getting the value of 103
        System.out.println("The Value associated to "
                + "103 is : " + m.get(103));
    }
}

// Java Program for traversing a
// ConcurrentHashMap
import java.util.*;
import java.util.concurrent.*;
public class Geeks {
    public static void main(String[] args)
    {
        // create an instance of ConcurrentHashMap
        ConcurrentHashMap<Integer, String> m
                = new ConcurrentHashMap<Integer, String>();

        // Add elements using put()
        m.put(8, "Third");
        m.put(6, "Second");
        m.put(3, "First");
        m.put(11, "Fourth");

        // Create an Iterator over the
        // ConcurrentHashMap
        Iterator<ConcurrentHashMap.Entry<Integer, String> >
                i = m.entrySet().iterator();

        // The hasNext() method is used to check if there is
        // a next element The next() method is used to
        // retrieve the next element
        while (i.hasNext()) {
            ConcurrentHashMap.Entry<Integer, String> entry
                    = i.next();
            System.out.println("Key = " + entry.getKey()
                    + ", Value = "
                    + entry.getValue());
        }
    }
}