Skip to content
Related Articles

Related Articles

Improve Article

Java Program to Implement HashTable API

  • Last Updated : 22 Feb, 2021

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.  

To implement Hashtable API first, we create a class “Hashtable” and create all the methods of the Hashtable in this class:

Java




// Java program to implement the hashTable API
  
import java.util.*;
import java.util.Map.Entry;
   
class HashTableImplementation<K, V>
{
    private Hashtable<K, V> hashTable;
   
    // Constructor creates a new HashTable 
    public HashTableImplementation()
    {
        hashTable = new Hashtable<K, V>();
    }
   
    // Constructor creates a new empty Hashtable 
    // according to the given Hashtable
    public HashTableImplementation(Map<? extends K, ? extends V> hashTable1)
    {
        hashTable = new Hashtable<K, V>(hashTable1);
    }
   
    // Removes all of the elements from the hashTable
    public void clear()
    {
        hashTable.clear();
    }
   
    // Creates a shallow copy of the hashtable
    public Object clone()
    {
        return hashTable.clone();
    }
   
    // Check whether the given Object contains in the hashTable
    public boolean contains(Object obj)
    {
        return hashTable.contains(obj);
    }
   
    // Returns true if the hashtable contains given value otherwise return false
    public boolean containsValue(Object val)
    {
        return hashTable.containsValue(val);
    }
   
    // Returns true if the hashTable contains given key otherwise return false
    public boolean containsKey(Object key)
    {
        return hashTable.containsKey(key);
    }
   
    // Returns an enumeration of the values in the hashtable
    public Enumeration<V> elements()
    {
        return hashTable.elements();
    }
   
    // Returns a set of entry of hashTable
    public Set<Map.Entry<K, V>> entrySet()
    {
        return hashTable.entrySet();
    }
   
    // Return true if hashTable equals to the given Object
    public boolean equals(Object obj)
    {  
        return hashTable.equals(obj);
    }
   
    // Returns the value to which the specified key is mapped, 
    // or null if the map contains no mapping for the key.
    public V get(Object key)
    {
        return hashTable.get(key);
    }
   
    // Returns the hash code value for the Map 
    public int hashCode()
    {
        return hashTable.hashCode();
    }
   
    // Check whether hashTable is empty or not
    public boolean isEmpty()
    {
        return hashTable.isEmpty();
    }
   
    // Returns an enumeration of the keys in on the hashtable
    public Enumeration<K> keys()
    {
        return hashTable.keys();
    }
   
    // Returns a Set view of the keys
    public Set<K> keySet()
    {
        return hashTable.keySet();
    }
   
    // Maps the specified key to the specified value in this hashTable
    public V put(K key, V val)
    {
        return hashTable.put(key, val);
    }
   
    // Returns the number of keys in the hashtable
    public int size()
    {
        return hashTable.size();
    }
   
    //Returns a string representation of the Hashtable objects in the form of String
    public String toString()
    {
        return hashTable.toString();
    }
   
    // Removes the given key with the value from the hashTable
    public V remove(Object key)
    {
        return hashTable.remove(key);
    }
   
    // Returns a Collection view of the values
    public Collection<V> values()
    {
        return hashTable.values();
    }
}
public class GFG{ 
    public static void main(String[] arg)
    {
        HashTableImplementation<String, Integer> hashTable = 
                         new HashTableImplementation<>();
          
        // Add elements to hashTable
        hashTable.put("Nikhil", 390);
        hashTable.put("Akshay", 280);
        hashTable.put("Bina", 500);
        hashTable.put("Chintu", 450);
          
        // Print the size of the hashTable
        System.out.println("The size of the hashTable: " + hashTable.size());
          
        // Iterate and print the EntrySet of the hashTable
        System.out.println("Entry Set of the hashTable: ");
        Set<Entry<String, Integer>> entrySet = hashTable.entrySet();
        Iterator<Entry<String, Integer>> entry = entrySet.iterator();
        
        while (entry.hasNext())
        {
            System.out.println(entry.next() + " ");
        }
        System.out.println();
          
        // Iterate and print the keys of the hashTable
        System.out.println("The keys of the HashTable: ");
        
        Set<String> keySet = hashTable.keySet();
        
        Iterator<String> it = keySet.iterator();
        
        while (it.hasNext())
        {
            System.out.print(it.next() + " ");
        }
        System.out.println();
          
        // Iterate and print the value of the hashTable
        System.out.println("The values of the HashTable:");
        
        Collection<Integer> values = hashTable.values();
        
        Iterator<Integer> itr = values.iterator();
        while (itr.hasNext())
        {
            System.out.print(itr.next() + " ");
        }
        System.out.println();
          
        // Print true if hashTable contains the key "Nikhil" 
        System.out.println("The hashTable contains Nikhil: "
                           + hashTable.containsKey("Nikhil"));
          
        // Delete all the entrys
        hashTable.clear();
          
        // Print size of the hashTable
        System.out.println("The size of the hashTable: " 
                           + hashTable.size());
          
    }
}
Output
The size of the hashTable: 4
Entry Set of the hashTable: 
Chintu=450 
Nikhil=390 
Akshay=280 
Bina=500 

The keys of the HashTable: 
Chintu Nikhil Akshay Bina 
The values of the HashTable:
450 390 280 500 
The hashTable contains Nikhil: true
The size of the hashTable: 0

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :