Hashtable in Java

The Hashtable class implements a hash table, which maps keys to values. Any

non-null object can be used as a key or as a value. To successfully store and
retrieve objects from a hashtable, the objects used as keys must implement the
hashCode method and the equals method.  

Declaration:
public class Hashtable<K,V> extends Dictionary<K,V> implements
Map<K,V>, Cloneable, Serializable
Type Parameters:
● K – the type of keys maintained by this map
● V – the type of mapped values

Constructors:

In order to create a Hashtable, we need to import it from java.util.Hashtable.

There are various ways in which we can create a Hashtable.

1. Hashtable(): This creates an empty hashtable. 

Hashtable<K, V> ht = new Hashtable<K, V>();

● Java

// Java program to demonstrate

// adding elements to Hashtable

  

import java.io.*;

import java.util.*;
  

class AddElementsToHashtable {

    public static void main(String args[])

    {

        // No need to mention the

        // Generic type twice

        Hashtable<Integer, String> ht1 = new Hashtable<>();

  

        // Initialization of a Hashtable

        // using Generics

        Hashtable<Integer, String> ht2 = new Hashtable<Integer, String>();

  

        // Inserting the Elements

        // using put() method

        ht1.put(1, "one");

        ht1.put(2, "two");

        ht1.put(3, "three");

  

        ht2.put(4, "four");
        ht2.put(5, "five");

        ht2.put(6, "six");

  

        // Print mappings to the console

        System.out.println("Mappings of ht1 : " + ht1);

        System.out.println("Mappings of ht2 : " + ht2);

    }

Output
Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {6=six, 5=five, 4=four}
2. Hashtable(int initialCapacity): This creates a hash table that has an initial
size specified by initialCapacity .

Hashtable<K, V> ht = new Hashtable<K, V>(int initialCapacity);

● Java

// Java program to demonstrate

// adding elements to Hashtable

  

import java.io.*;

import java.util.*;
  

class AddElementsToHashtable {

    public static void main(String args[])

    {

        // No need to mention the

        // Generic type twice

        Hashtable<Integer, String> ht1 = new Hashtable<>(4);

  

        // Initialization of a Hashtable

        // using Generics

        Hashtable<Integer, String> ht2

            = new Hashtable<Integer, String>(2);

  

        // Inserting the Elements

        // using put() method

        ht1.put(1, "one");

        ht1.put(2, "two");

        ht1.put(3, "three");

  
        ht2.put(4, "four");

        ht2.put(5, "five");

        ht2.put(6, "six");

  

        // Print mappings to the console

        System.out.println("Mappings of ht1 : " + ht1);

        System.out.println("Mappings of ht2 : " + ht2);

    }

Output
Mappings of ht1 : {3=three, 2=two, 1=one}
Mappings of ht2 : {4=four, 6=six, 5=five}
3. Hashtable(Map<? extends K,? extends V> m): This creates a hash table
that is initialized with the elements in m.
Hashtable<K, V> ht = new Hashtable<K, V>(Map m);

● Java

// Java program to demonstrate

// adding elements to Hashtable

  

import java.io.*;

import java.util.*;
  Continue from down below here next lesson

class AddElementsToHashtable {

    public static void main(String args[])

    {

        // No need to mention the

        // Generic type twice

        Map<Integer, String> hm = new HashMap<>();

  

        // Inserting the Elements

        // using put() method

        hm.put(1, "one");

        hm.put(2, "two");

        hm.put(3, "three");

  

        // Initialization of a Hashtable

        // using Generics

        Hashtable<Integer, String> ht2  = new Hashtable<Integer, String>(hm);

  

        // Print mappings to the console

  

        System.out.println("Mappings of ht2 : " + ht2);

    }

Output
Mappings of ht2 : {3=three, 2=two, 1=one}
Example:
● Java

// Java program to illustrate

// Java.util.Hashtable

  

import java.util.*;

  

public class GFG {

    public static void main(String[] args)

    {

        // Create an empty Hashtable

        Hashtable<String, Integer> ht = new Hashtable<>();

  
        // Add elements to the hashtable

        ht.put("vishal", 10);

        ht.put("sachin", 30);

        ht.put("vaibhav", 20);

  

        // Print size and content

        System.out.println("Size of map is:- " + ht.size());

        System.out.println(ht);

  

        // Check if a key is present and if

        // present, print value

        if (ht.containsKey("vishal")) {

            Integer a = ht.get("vishal");

            System.out.println("value for key"

                               + " \"vishal\" is:- " + a);

        }

    }

 
 
Output
Size of map is:- 3
{vaibhav=20, vishal=10, sachin=30}
value for key "vishal" is:- 10
Performing Various Operations on Hashtable                  
1. Adding Elements: In order to add an element to the hashtable, we can use
the put() method. However, the insertion order is not retained in the hashtable.
Internally, for every element, a separate hash is generated and the elements are
indexed based on this hash to make it more efficient.                      
● Java

// Java program to demonstrate

// adding elements to Hashtable

  

import java.io.*;

import java.util.*;

  

class AddElementsToHashtable {

    public static void main(String args[])

    {

        // No need to mention the

        // Generic type twice

        Hashtable<Integer, String> ht1 = new Hashtable<>();

  
        // Initialization of a Hashtable

        // using Generics

        Hashtable<Integer, String> ht2

            = new Hashtable<Integer, String>();

  

        // Inserting the Elements

          // using put() method

        ht1.put(1, "Geeks");

        ht1.put(2, "For");

        ht1.put(3, "Geeks");

  

        ht2.put(1, "Geeks");

        ht2.put(2, "For");

        ht2.put(3, "Geeks");

          

          // Print mappings to the console

        System.out.println("Mappings of ht1 : " + ht1);

        System.out.println("Mappings of ht2 : " + ht2);

    }
}

 
Output
Mappings of ht1 : {3=Geeks, 2=For, 1=Geeks}
Mappings of ht2 : {3=Geeks, 2=For, 1=Geeks}
2. Changing Elements: After adding the elements if we wish to change the
element, it can be done by again adding the element with the put() method. Since
the elements in the hashtable are indexed using the keys, the value of the key
can be changed by simply inserting the updated value for the key for which we
wish to change.
● Java

// Java program to demonstrate

// updating Hashtable

  

import java.io.*;

import java.util.*;

class UpdatesOnHashtable {

    public static void main(String args[])

    {

  

        // Initialization of a Hashtable

        Hashtable<Integer, String> ht
            = new Hashtable<Integer, String>();

  

        // Inserting the Elements

          // using put method

        ht.put(1, "Geeks");

        ht.put(2, "Geeks");

        ht.put(3, "Geeks");

          

          // print initial map to the console

        System.out.println("Initial Map " + ht);

          

          // Update the value at key 2

        ht.put(2, "For");

          

          // print the updated map

        System.out.println("Updated Map " + ht);

    }

 
Output
Initial Map {3=Geeks, 2=Geeks, 1=Geeks}
Updated Map {3=Geeks, 2=For, 1=Geeks}
3. Removing Element: In order to remove an element from the Map, we can use
the remove() method. This method takes the key value and removes the
mapping for a key from this map if it is present in the map.
● Java

// Java program to demonstrate

// the removing mappings from Hashtable

  

import java.io.*;

import java.util.*;

class RemovingMappingsFromHashtable {

  

    public static void main(String args[])

    {

        // Initialization of a Hashtable

        Map<Integer, String> ht

            = new Hashtable<Integer, String>();

  

        // Inserting the Elements

          // using put method

        ht.put(1, "Geeks");

        ht.put(2, "For");

        ht.put(3, "Geeks");

        ht.put(4, "For");

  

        // Initial HashMap

        System.out.println("Initial map : " + ht);

  

          // Remove the map entry with key 4

        ht.remove(4);

  

        // Final Hashtable

        System.out.println("Updated map : " + ht);

    }

Output
Initial map : {4=For, 3=Geeks, 2=For, 1=Geeks}
Updated map : {3=Geeks, 2=For, 1=Geeks}
4. Traversal of a Hashtable: To iterate the table, we can make use of
an advanced for loop. Below is the example of iterating a hashtable.
● Java
// Java program to illustrate

// traversal of Hashtable

  

import java.util.Hashtable;

import java.util.Map;

  

public class IteratingHashtable {

    public static void main(String[] args)

    {

          // Create an instance of Hashtable

        Hashtable<String, Integer> ht = new Hashtable<>();

  

          // Adding elements using put method

        ht.put("vishal", 10);

        ht.put("sachin", 30);

        ht.put("vaibhav", 20);

      

          // Iterating using enhanced for loop

        for (Map.Entry<String, Integer> e : ht.entrySet())

            System.out.println(e.getKey() + " "

                               + e.getValue());

    }

Output
vaibhav 20
vishal 10
sachin 30

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.

// Java program to demonstrate working of LinkedHashMap

import java.util.*;

public class LinkedHashMapExample {

public static void main(String a[])

{
// create an instance of LinkedHashMap
LinkedHashMap<String, String> lhm
= new LinkedHashMap<String, String>();
// Add mappings using put method
lhm.put("one", "practice.geeksforgeeks.org");
lhm.put("two", "code.geeksforgeeks.org");
lhm.put("four", "quiz.geeksforgeeks.org");

// It prints the elements in same order

// as they were inserted
System.out.println(lhm);

System.out.println("Getting value for key 'one': "

+ lhm.get("one"));

System.out.println("Size of the map: "

+ lhm.size());

System.out.println("Is map empty? "

+ lhm.isEmpty());

System.out.println("Contains key 'two'? "

+ lhm.containsKey("two"));

System.out.println(
"Contains value 'practice.geeks"
+ "forgeeks.org'? "
+ lhm.containsValue("practice"
 + ".geeksforgeeks.org"));

System.out.println("delete element 'one': "

+ lhm.remove("one"));

// print mappings to the console

System.out.println("Mappings of LinkedHashMap : "
+ lhm);
}
}

Output
{one=practice.geeksforgeeks.org, two=code.geeksforgeeks.org,
four=quiz.geeksforgeeks.org}
Getting value for key 'one': practice.geeksforgeeks.org
Size of the map: 3
Is map empty? false
Contains key 'two'? true
Contains value 'practice.geeksforgeeks.org'? true
delete element 'one': practice.geeksforgeeks.org
Mappings of LinkedHashMap : {two=code.geeksforgeeks.org,
four=quiz.geeksforgeeks.org}
How to sort the Hashtable by values in Java?
The Hashtable class in Java does not maintain the order of its entries, so even if we sort
it, there is no guarantee that the elements will be returned in that order. We need to
convert a hashtable to a collection that maintains the element order.

How to sort Hashtable by values if you only want values?

We can get all the values from the hashtable using the values method, convert it to a
List (like ArrayList or LinkedList) and then we can sort the List using the sort method of
the Collections class as given below.

1 Hashtable<String, Integer> htRandomNumbers = new Hashtable<String, Integer>();

3 htRandomNumbers.put("Five", 5);

4 htRandomNumbers.put("Three", 3);

5 htRandomNumbers.put("Nine", 9);

6 htRandomNumbers.put("Seven", 7);

7 htRandomNumbers.put("Two", 2);

9 System.out.println( "Hashtable contains: " + htRandomNumbers );

10

11 /*

12 * Get all hashtable values using

13 * the value method and convert it

14 * to a List

15 */

16 List<Integer> list = new ArrayList<Integer>( htRandomNumbers.values() );

17

18 /*

19 * Sort the list using the sort method

20 * of the Collections class

21 */
 22 Collections.sort(list);

23

24 System.out.println("Sorted values: " + list);

Output

1 Hashtable contains: {Seven=7, Three=3, Nine=9, Two=2, Five=5}

2 Sorted values: [2, 3, 5, 7, 9]

The sort method of the Collections class sorts the list elements in their natural order,
which is the ascending order for the type Integer. If you want to sort the values in
descending order, pass the reverse comparator in the sort method as given below.

1 Collections.sort(list, Collections.reverseOrder());

Output

1 Hashtable contains: {Seven=7, Three=3, Nine=9, Two=2, Five=5}

2 Sorted values: [9, 7, 5, 3, 2]

How to print LinkedHashMap in ascending order:-

LinkedHashMap maintains insertion order. Convert LinkedHashMap into

TreeMap and after that print keys of TreeMap which are sorted in nature.
Example:
Input: linkedHashMap = {{5,4}, {3,44}, {4,15}, {1,20}, {2,11}}
Output:
key -> 1 : value -> 20
key -> 2 : value -> 11
key -> 3 : value -> 44
key -> 4 : value -> 15
key -> 5: value -> 4

Approach:
1. Take LinkedHashMap as an input.
2. Create a new TreeMap.
3. Pass LinkedHashMap object into the constructor of TreeMap.
4. Print Keys of TreeMap object.

Below is the implementation of the above approach:

● Java
// Sort LinkedHashMap by keys in Java
import java.util.*;
import java.io.*;

class GFG {
public static void main(String[] args)
{
LinkedHashMap<Integer, Integer> lMap
= new LinkedHashMap<>();

// adding key-value pairs to LinkedHashMap

object
lMap.put(5, 4);
lMap.put(3, 44);
lMap.put(4, 15);
lMap.put(1, 20);
lMap.put(2, 11);
System.out.println("After Sorting :\n");

// convert to TreeMap
Map<Integer, Integer> map = new
TreeMap<>(lMap);

// iterate acc to ascending order of keys

for (Integer sKey : map.keySet()) {
System.out.println("Key -> " + sKey
 + ": Value -> "
+ lMap.get(sKey));
}
}
}

Output
After Sorting :

Key -> 1: Value -> 20

Key -> 2: Value -> 11
Key -> 3: Value -> 44
Key -> 4: Value -> 15
Key -> 5: Value -> 4