Hashtable in Java

Hashtable in Java

The Hashtable class implements the Map interface and extends the Dictionary class. It implements a hash table which shows the key-value relation, i.e., it maps the keys to the values. Hashtable contains bucket (index) to store the key-value pair. The key’s hashcode is used to determine to which bucket the key-value pair should be mapped.

• Hashtable is similar to HashMap, but it is synchronized whereas HashMap is not.
• The object that is used as a key or as a value must not be null.
• For successful storing and fetching of the object from the Hashtable, the object must implement the hashcode() and the equals() methods.
• The hash function is used to get a bucket location from the key’s hashcode. A hash function always returns a number for an Object.

Let’s take the hashtable with & buckets :

The performance of the hashtable is affected by its two parameters, i.e., initial capacity and load factor.

Initial Capacity-The number of buckets in the hashtable denotes its capacity. And the initial capacity is the capacity at the time hashtable is created. If the initial capacity is larger than the maximum number of entries the hashtable then, the rehash operation will not occur. The tradeoff between wasted space and requirement of rehash operation is controlled by initial capacity.

Load Factor-It is a measure of space acquired by the hashtable that is allowed to get before its capacity is automatically increased.

If we need to insert a large number of entries into the hashtable, it is better to create it with large capacity. It allows the values to be inserted more efficiently than letting it to perform automatic rehashing as required to grow the table.

Constructors of Hashtable

Methods of Hashtable

Example to illustrate clear() and clone() method:

import Java.util.*;
class HashClearDemo {
    public static void main(String[] arg)
    {
        //initializing hash table
        Hashtable<Integer, String> h1 = new Hashtable<Integer, String>();
        Hashtable<Integer, String> h2 = new Hashtable<Integer, String>();
        h1.put(1, "Java");
        h1.put(2, "JavaScript");
        h1.put(3, "Oracle");
        // create a clone or shallow copy of hash table h
        h2 = (Hashtable<Integer, String>)h1.clone();
        // printing entries in cloned hashmap
        System.out.println("Entries in clone HashTable: " + h2);
        // clearing hash table using clear() method
        h1.clear();
        // checking hash table h
        System.out.println("After using clear(): " + h1);
    }
} 

Output:

Entries in clone HashTable: {3=Oracle, 2=JavaScript, 1=Java}
After using clear(): {} 

Example to illustrate forEach(BiConsumer action) method:

import Java.util.*;
public class ForEachDemo {
    public static void main(String[] args)
    {
        // creating a hashtable
        Map<String, Integer> price = new Hashtable<>();
        //adding entries to the table
        price.put("Sweets", 50);
        price.put("Dosa", 60);
        price.put("Icecream", 20);
        price.put("Salat", 80);
        price.put("Fruits", 100);
        // increasing 50 price for every product using forEach()
        price.forEach((k, v) ->
        {  
            v = v + 50;
            price.replace(k, v);
        });
        // printing new mapping using forEcah() method
        price.forEach(
            (k, v) -> System.out.println(k + ", price : " + v));
    }
} 

Output:

Sweets, price : 100
Icecream, price : 70
Salat, price : 130
Fruits, price : 150
Dosa, price : 110 

Example to demonstrate computeIfAbsent(Key, Function) method.

import Java.util.*;
class AbsentDemo {
    public static void main(String[] args)
    {
        // create a table and add some values
        Map<Integer, String> t = new Hashtable<>();
        t.put(1, "Java");
        t.put(2, "Spring");
        t.put(3, "Hibernate");
        // printing map details
        System.out.println("HashTable: "+ t.toString());
        // adding new key-value pair using computeIfAbsent method
        t.computeIfAbsent(4, k -> "Pyhton");
        // this will not affect anything in the hash table because key 1 already exist
        t.computeIfAbsent(1, k -> "Oracle");
        // print new mapping
        System.out.println("New hashTable: "+ t);
    }
} 

Output:

hashTable: {3=Hibernate, 2=Spring, 1=Java}
new hashTable: {4=Pyhton, 3=Hibernate, 2=Spring, 1=Java} 

Example to illustrate the isEmpty() method

import Java.util.*;
class EmptyDemo {
    public static void main(String[] args)
    {
        // creating an empty Hashtable
        Hashtable<String, Integer> h1 = new Hashtable<String, Integer>();
        Hashtable<String, Integer> h2 = new Hashtable<String, Integer>();
        // adding elements into the table
        h1.put("Java", 10);
        h1.put("Python", 15);
        h1.put("pytorch", 20);
        h1.put("Salesforce", 25);
        h1.put("AWS", 30);
        // printing the Hashtable
        System.out.println("Elements in 1st table are: " + h1);
        System.out.println("Elements in 2nd table are: " + h2);
        // checking if the table is empty
        System.out.println("First table is empty !! " + h1.isEmpty());
        System.out.println("Second table is empty !!" + h2.isEmpty());
    }
} 

Output:

Elements in 1st table are: {Java=10, AWS=30, Python=15, Salesforce=25, pytorch=20}
Elements in 2nd table are: {}
First table is empty!! False
Second table is empty!!True 

Example to demonstrate compute(Key, BiFunction) method.

import Java.util.*;
class computeDemo {
    public static void main(String[] args)
    {
        // creating a table and adding some tutorial and its fees
        Map<String, Integer> h = new Hashtable<>();
        h.put("Java", 10000);
        h.put("Python", 12000);
        h.put("AWS", 18000);
        h.put("Salesforce", 8000);
        // printing map details
        System.out.println("Tutorial price: " + h.toString());
        // remapping the values of hashTable using compute method
        h.compute("Java", (key, val)
                                 -> val + 2000);
        h.compute("AWS", (key, val)
                                     -> val - 3000);
        // print new mapping
        System.out.println("New Tutorial Price: " + h);
    }
} 

Output:

Tutorial price: {Java=10000, Salesforce=8000, AWS=18000, Python=12000}
New Tutorial Price: {Java=12000, Salesforce=8000, AWS=15000, Python=12000} 

Example to illustrate the put() and get() method.

import Java.util.*;
class PutGetDemo {
    public static void main(String[] args)
    {
        // Creating an empty Hashtable
        Hashtable<Integer, String> h = new Hashtable<Integer, String>();
        // Inserting the values into table using put() method
        h.put(1, "Java");
        h.put(2, "Python");
        h.put(3, "Oracle");
        h.put(4, "Spring");
        h.put(5, "JDBC");
        // printing the Hashtable
        System.out.println("Initial Table is: " + h);
        // Getting the value at 4
        System.out.println("The Value at 4 is: " + h.get(4));
        // Getting the value at 1
        System.out.println("The Value at 1 is: " + h.get(1));
    }
} 

Output:

Initial Table is: {5=JDBC, 4=Spring, 3=Oracle, 2=Python, 1=Java}
The Value at 4 is: Spring
The Value at 1 is: Java 

Example to illustrate the containsValue() method.

import Java.util.*;
class ContainValueDemo {
    public static void main(String[] args)
    {
        // Initializing an empty Hashtable
        Hashtable<Integer, String> h = new Hashtable<Integer, String>();
        // adding values in the table
        h.put(10, "Java");
        h.put(15, "Pyhton");
        h.put(20, "Data Structure");
        h.put(25, "OS");
        h.put(30, "Andriod");
        // Displaying the Hashtable
        System.out.println("Initial Table is: " + h);
        // Checking for the Value 'Java'
        System.out.println("Is the value 'Java' present? " + h.containsValue("Java"));
        // Checking for the Value 'OS'
        System.out.println("Is the value 'OS' present? " + h.containsValue("OS"));
    }
} 

Output:

Initial Table is: {5=JDBC, 4=Spring, 3=Oracle, 2=Python, 1=Java}
The Value at 4 is: Spring
The Value at 1 is: Java 

Example to illustrate the containsKey() method

import Java.util.*;
public class ContainsKeyDemo {
    public static void main(String[] args)
    {
        // Initializing an empty Hashtable
        Hashtable<Integer, String> h =  new Hashtable<Integer, String>();
        // adding values into the table
        h.put(1, "Java");
        h.put(2, "Pyhton");
        h.put(3, "Data Structure");
        h.put(4, "OS");
        h.put(5, "Andriod");
        // printing the Hashtable
        System.out.println("Initial Table is: " + h);
        // Checking for the key_element '20'
        System.out.println("Is the key '2' present? " +  h.containsKey(2));
        // Checking for the key_element '5'
        System.out.println("Is the key '6' present? " + h.containsKey(6));
    }
} 

Output:

Initial Table is: {5=Andriod, 4=OS, 3=Data Structure, 2=Pyhton, 1=Java}
Is the key '2' present? true
Is the key '6' present? False 

Example to illustrating Enumeration keys() method

import Java.util.*;
class EnumKeyDemo {
    public static void main(String[] arg)
    {
        // creating a hash table
        Hashtable<Integer, String> h = new Hashtable<Integer, String>();      
        h.put(3, "Ankit");
        h.put(2, "Himanshu");
        h.put(1, "Aakash");
        // create enumeration
        Enumeration e1 = h.keys();
        System.out.println("keys are:");
        while (e1.hasMoreElements()) {
            System.out.println(e1.nextElement());
        }
    }
} 

Output:

keys are:
3
2
1 

Example to illustrating hashCode() method

import Java.util.*;
class HashCodeDemo {
    public static void main(String[] arg)
    {
        // creating a hash table
        Hashtable<Integer, String> h =  new Hashtable<Integer, String>();
        h.put(3, "Java");
        h.put(2, "Spring");
        h.put(1, "Hibernate");
        // obtaining hash code
        System.out.println("Hash code is: " + h.hashCode());
    }
} 

Output:

Hash code is: -709507933

Example to illustrating entrySet() method

import Java.util.*;
class EntrySetDemo {
    public static void main(String[] arg)
    {
        // initializing a hash table
        Hashtable<Integer, String> h = 
               new Hashtable<Integer, String>();
        h.put(3, "Ankit");
        h.put(2, "Sumit");
        h.put(1, "Anubhav");
        // initializing set view for hash table
        Set s = h.entrySet();
        // obtaining set entries
        System.out.println("set entries: " + s);
    }
} 

Output:

set entries: [3=Ankit, 2=Sumit, 1=Anubhav]