HashMap Class Methods in Java with Examples | Set 1 (put(), get(), isEmpty() and size())

HashMap is a data structure that uses a hash function to map identifying values, known as keys, to their associated values. It contains "key-value" pairs and allows retrieving value by key. 
The most impressive feature is it's fast lookup of elements especially for large no. of elements. It is not synchronized by default but we can make it so by calling

 Map myhash = Collections.synchronizedMap(hashMap);

at creation time, to prevent accidental unsynchronized access to the map. 
These are various important hashmap class methods. This post explains: put(), get(), isEmpty() and size()

1. put(): java.util.HashMap.put() plays role in associating the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced. Syntax:

public V put(K key,V value)
Parameters:
key - key with which the specified value is to be associated
value - value to be associated with the specified key
Return: the previous value associated with
key, or null if there was no mapping for key. 

       2. get(): java.util.HashMap.get()method returns the value to which the specified key is mapped, or null if this map contains no mapping for the key. Syntax:

public V get(Object key)
Parameters:
key - the key whose associated value is to be returned
Return: the value to which the specified 
key is mapped, or null if this map contains no mapping for
the key.

       3. isEmpty(): java.util.HashMap.isEmpty() method returns true if the map contains no key-value mappings. Syntax:

public boolean isEmpty()
Return: true if this map contains no key-value mappings

       4. size(): java.util.HashMap.size() returns the number of key-value mappings in this map. Syntax:

public int size()
Return: the number of key-value mappings in this map.

      5. remove(): java.util.HashMap.remove() removes the key-value pair associated with the specified key from the HashMap. Syntax:

public V remove(Object key)
Parameters:
key - the key whose mapping is to be removed from the map.
Return: the previous value associated with the key, or null if there was no mapping for the key.

      6. containsKey(): java.util.HashMap.containsKey() returns true if the HashMap contains the specified key, otherwise it returns false. Syntax:

public boolean containsKey(Object key)
Parameters:
key - the key whose presence in this map is to be tested.
Return: true if this map contains a mapping for the specified key, false otherwise.

      7. containsValue(): java.util.HashMap.containsValue() returns true if the HashMap contains the specified value, otherwise it returns false. Syntax:

public boolean containsValue(Object value)
Parameters:
value - the value whose presence in this map is to be tested.
Return: true if this map maps one or more keys to the specified value, false otherwise.

      8. clear(): java.util.HashMap.clear() removes all the key-value pairs from the HashMap. Syntax:

public void clear()
Return: None (void).

     9. keySet(): java.util.HashMap.keySet() returns a Set containing all the keys in the HashMap. Syntax:

public Set<K> keySet()
Return: A Set view of the keys contained in this map.

      10. values(): java.util.HashMap.values() returns a Collection containing all the values in the HashMap. Syntax:

public Collection<V> values()
Return: A Collection view of the values contained in this map.

      11. entrySet(): java.util.HashMap.entrySet() returns a Set containing all the key-value pairs in the HashMap as Map.Entry objects. Syntax:

public Set<Map.Entry<K,V>> entrySet()
Return: A set view of the mappings contained in this map.

Implementation to illustrate above methods 

// Java program illustrating use of HashMap methods -

import java.util.*;
public class NewClass {
    public static void main(String args[])
    {
        // Creation of HashMap
        HashMap<String, String> Geeks = new HashMap<>();

        // Adding values to HashMap using put() method
        Geeks.put("Language", "Java");
        Geeks.put("Platform", "Geeks For Geeks");
        Geeks.put("Code", "HashMap");
        Geeks.put("Learn", "More");

        // Printing out the values of the HashMap
        System.out.println("HashMap Contents: " + Geeks);
        // Printing the size of the HashMap
        System.out.println("The size of the HashMap is: "
                           + Geeks.size());

        // Using the get() method to retrieve a value from
        // the HashMap
        String language = Geeks.get("Language");
        System.out.println("Language: " + language);

        // Using the containsKey() method to check if a key
        // exists in the HashMap
        boolean containsKey = Geeks.containsKey("Code");
        System.out.println("Contains Key 'Code'? "
                           + containsKey);

        // Using the containsValue() method to check if a
        // value exists in the HashMap
        boolean containsValue = Geeks.containsValue("More");
        System.out.println("Contains Value 'More'? "
                           + containsValue);

        // Using the keySet() method to retrieve a Set of
        // all keys in the HashMap
        Set<String> keySet = Geeks.keySet();
        System.out.println("Key Set: " + keySet);

        // Using the values() method to retrieve a
        // Collection of all values in the HashMap
        Collection<String> values = Geeks.values();
        System.out.println("Values: " + values);

        // Using the entrySet() method to retrieve a Set of
        // all key-value pairs in the HashMap
        Set<Map.Entry<String, String> > entrySet
            = Geeks.entrySet();
        System.out.println("Entry Set: " + entrySet);

        // Using the remove() method to remove a key-value
        // pair from the HashMap
        String removedValue = Geeks.remove("Code");
        System.out.println("Removed Value: "
                           + removedValue);

        // Using the clear() method to remove all key-value
        // pairs from the HashMap
        Geeks.clear();
        System.out.println(
            "HashMap Contents after clear(): " + Geeks);

        // Using the isEmpty() method to check if the
        // HashMap is empty
        boolean isEmpty = Geeks.isEmpty();
        System.out.println("Is Empty? " + isEmpty);
    }
}

HashMap Contents: {Language=Java, Platform=Geeks For Geeks, Learn=More, Code=HashMap}
The size of the HashMap is: 4
Language: Java
Contains Key 'Code'? true
Contains Value 'More'? true
Key Set: [Language, Platform, Learn, Code]
Values: [Java, Geeks For Geeks, More, HashMap]
Entry Set: [Language=Java, Platform=Geeks For Geeks, Learn=More, Code=HashMap]
Removed Value: HashMap
HashMap Contents after clear(): {}
Is Empty? true

What are the differences between HashMap and TreeMap?

1. HashMap implements Map interface while TreeMap implements SortedMap interface. A Sorted Map interface is a child of Map.
2. HashMap implements Hashing, while TreeMap implements Red-Black Tree(a Self Balancing Binary Search Tree). Therefore all differences between Hashing and Balanced Binary Search Tree apply here.
3. Both HashMap and TreeMap have their counterparts HashSet and TreeSet. HashSet and TreeSet implement Set interface. In HashSet and TreeSet, we have only key, no value, these are mainly used to see presence/absence in a set. For above problem, we can’t use HashSet (or TreeSet) as we can’t store counts. An example problem where we would prefer HashSet (or TreeSet) over HashMap (or TreeMap) is to print all distinct elements in an array.

Refer HashMap and TreeMap for details. What are differences between HashMap and HashTable in Java?

• HashMap is non synchronized. It is not-thread safe and can’t be shared between many threads without proper synchronization code whereas Hashtable is synchronized. It is thread-safe and can be shared with many threads.
• HashMap allows one null key and multiple null values whereas Hashtable doesn’t allow any null key or value.
• HashMap is generally preferred over HashTable if thread synchronization is not needed
• HashMap is an advanced version and improvement on the Hashtable. HashMap was created later.

Please Refer Differences between HashMap and HashTable in Java for details. What are differences between HashMap and HashSet?

• HashMap stores key value pairs (for example records of students as value and roll number as key) and HashSet stores only keys (for example a set if integers).
• HashSet internally uses HashMap to store keys

Please refer HashSet in Java for details. Hashmap methods in Java with Examples | Set 2 (keySet(), values(), containsKey()) Reference: https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html