What Is A Java HashTable: HashTable Implementation & Example

This Tutorial Explains What is a Java HashTable, Constructors, and Methods of Hashtable Class, Implementation & Hashtable vs Hashmap:

What Is A HashTable?

A Hashtable in Java is an array of elements that are lists. Each of these lists is termed a bucket.

It maps the keys to values. In Java, the hash table is implemented by the ‘HashTable’ class. This class implements the map interface and inherits the dictionary class.

=> Check Out The Perfect Java Training Guide Here.

Some of the unique characteristics of Hashtable in Java are as follows:

1. It is an array that contains lists or buckets as its elements.
2. It has unique elements.
3. There is no null key or null value in the Hashtable.
4. It is similar to Hashmap but is synchronized.

HashTable Class In Java

In Java, this class is a member of java.util package. Thus we have to include one of the following statements in our program to include HashTable class functionality.

import java.util.*;

OR

import java.util.HashTable;

A general class declaration for java.util.HashTable class is given below:

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K, V>, Cloneable, Serializable

Here,

• K => type of keys of the HashTable
• V=> type of values mapped

The HashTable class API consists of constructors that are used to construct the class objects and the various operations or methods that are a part of the class which brings about smooth functioning of the HashTable class.

Constructors Of HashTable Class

Methods Of HashTable Class

Implementation Of HashTable

Given below is the implementation of the class in Java. Here we have demonstrated all the important methods provided by the class.

import java.util.*;  
class Main{  
 public static void main(String args[]){  
    //create a Hashtable and initiliaze it
    Hashtable<Integer,String> hash_tab=new Hashtable<Integer,String>();  
    hash_tab.put(100,"Red");  
    hash_tab.put(101,"Green");  
    hash_tab.put(104,"Blue");  
    hash_tab.put(102,"Orange");  
    hash_tab.put(103,"Brown");
    
    //obtain entrySet for the Hashtable and print the elments
    System.out.println("The contents of Hashtable:");
    for(Map.Entry m:hash_tab.entrySet()){  
        System.out.println(m.getKey()+" : "+m.getValue());  
    }  
    //getOrDefault operation => get the value at given key or output default message
    System.out.println("Hashtable Value at 101: " + hash_tab.getOrDefault(101, "Value Not Found"));  
    System.out.println("Hashtable Value at 105: " +hash_tab.getOrDefault(105, "Value Not Found"));  
    //remove operation => delete value at given key    
    hash_tab.remove(102);  
    System.out.println("After remove(102), the Hash Table: "+ hash_tab); 
    //putIfAbsent operation=>update the key-value pair in table if absent
    hash_tab.putIfAbsent(102,"Orange");  
    System.out.println("Updated Hash Table: "+hash_tab);  
 }  
}  

Output:

The contents of Hashtable:
104 : Blue
103 : Brown
102 : Orange
101 : Green
100 : Red
Hashtable Value at 101: Green
Hashtable Value at 105: Value Not Found
After remove(102), the Hash Table: {104=Blue, 103=Brown, 101=Green, 100=Red}
Updated Hash Table: {104=Blue, 103=Brown, 102=Orange, 101=Green, 100=Red}

HashTable Java Example

In this program, we define a hashtable with the keys as the account holder names with their respective account balances as values. First, we retrieve the keys from the HashTable as an enumeration. Then using this enumeration, we print the key-value pairs from the HashTable.

Later, we update the account balance of one of the holders and print the updated amount.

The program given below shows this implementation.

import java.util.*;
public class Main {

   public static void main(String args[]) {
      // Create a Hashtable of account balance
      Hashtable acc_balance = new Hashtable();
      Enumeration person_names;
      String name_str;
      double balance;
      //initialize the Hashtable
      acc_balance.put("Lily", new Double(4367.34));
      acc_balance.put("Ben", new Double(95.43));
      acc_balance.put("Lacy", new Double(1200.00));
      acc_balance.put("Dillon", new Double(499.22));
      acc_balance.put("James", new Double(78.48));

      // retrieve the keys of the Hashtable
      person_names = acc_balance.keys();
      
      System.out.println("The account balance Hashtable:");
      System.out.println("\t KEY     VALUE\t");
      //print the contents of Hashtable
      while(person_names.hasMoreElements()) {
         name_str = (String) person_names.nextElement();
         System.out.println("\t" + name_str + "\t" + acc_balance.get(name_str));
      }        
      System.out.println();
      
      // Update Ben's Account by adding 1000 to it.
      balance = ((Double)acc_balance.get("Ben")).doubleValue();
      acc_balance.put("Ben", new Double(balance + 1000));
      //print the contents of updated account
      System.out.println("Ben's new Account balance: " + acc_balance.get("Ben"));
   }
}

Output:

The account balance Hashtable:
KEY VALUE
James 78.48
Ben 95.43
Dillon 499.22
Lily 4367.34
Lacy 1200.0

Ben’s new Account balance: 1095.43

Hashtable Vs Hashmap

Frequently Asked Questions

Q #1) What is Hashtable in Java? 

Answer: It is a legacy class that inherits the “dictionary” class and stores key-value pairs.

Q #2) Why Hashtable is used?

Answer: It is used to store key-value pairs. So when we need to store the key-value pairs in the tabular format we go for HashTable. Secondly, it can store multiple values for the same key using buckets. Data retrieval is efficient in HashTables.

Q #3) How do you create a Hashtable in Java?

Answer: You can create it by instantiating an object of java.util.HashTable class.

HashTable<String,String> hashTable = new HashTable<String,String>();

The above statement creates a HashTable named ‘hashTable’ with Keys and values of type String.

Q #4) Is Hashtable thread-safe?

Answer: Yes, it is thread-safe. In case thread safeness is not required, then we can opt for HashMap.

Q #5) How does Hashtable work internally in Java with an example?

Answer: Internally it stores key-value pairs in a structure called buckets. The position of the bucket is determined by the key’s hashCode. The hash function gets the bucket location using the Key’s hashCode.

Conclusion

HashTable consists of data stored in the form of key-value pairs. The keys or values cannot be null. In Java, it is implemented using the HashTable class.

We have seen the constructors and methods provided by the HashTable class along with the implementation of HashTable in the Java language.

In our upcoming tutorial, we will discuss the HashMap collection.

=> Visit Here For The Exclusive Java Training Tutorial Series.