Implementing our Own Hash Table with Separate Chaining in Java

Hash tables are a fundamental data structure in computer science, providing efficient storage and retrieval of key-value pairs. They achieve average-case constant time complexity for search, insert, and delete operations, making them highly valuable for various applications such as database indexing, caching, and associative arrays. However, handling collisions-situations where multiple keys map to the same index-is crucial for maintaining their efficiency.

One common collision resolution technique is separate chaining, where each bucket of the hash table contains a linked list of entries that hash to the same index. This approach simplifies collision handling by allowing multiple key-value pairs to be stored in the same bucket without overwriting each other. In Java, separate chaining can be implemented using the built-in LinkedList class, providing a straightforward and effective way to manage collisions. We will create a custom hash table class that uses linked lists to handle collisions. This implementation will include methods for adding, retrieving, and removing key-value pairs, as well as displaying the hash table's contents.

HashTable Class with Separate Chaining

Node Class: A helper class for storing key-value pairs.

HashTable Class: The main class that implements the hash table with separate chaining.

 
import java.util.LinkedList;
class HashTable<K, V> {
    // Node class to store key-value pairs
    private class Node {
        K key;
        V value;        
        Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }
    private int capacity; // Number of buckets
    private LinkedList<Node>[] table; // Array of linked lists
    // Constructor to initialize the hash table with a given capacity
    public HashTable(int capacity) {
        this.capacity = capacity;
        table = new LinkedList[capacity];
        for (int i = 0; i < capacity; i++) {
            table[i] = new LinkedList<>();
        }
    }
    // Hash function to map keys to bucket indices
    private int hash(K key) {
        return Math.abs(key.hashCode()) % capacity;
    }
    // Method to add a key-value pair to the hash table
    public void put(K key, V value) {
        int index = hash(key);
        LinkedList<Node> bucket = table[index];
        for (Node node : bucket) {
            if (node.key.equals(key)) {
                node.value = value; // Update value if key already exists
                return;
            }
        }
        bucket.add(new Node(key, value)); // Add new node if key doesn't exist
    }
    // Method to get a value by key from the hash table
    public V get(K key) {
        int index = hash(key);
        LinkedList<Node> bucket = table[index];
        for (Node node : bucket) {
            if (node.key.equals(key)) {
                return node.value; // Return value if key is found
            }
        }
        return null; // Return null if key is not found
    }
    // Method to remove a key-value pair from the hash table
    public void remove(K key) {
        int index = hash(key);
        LinkedList<Node> bucket = table[index];
        Node toRemove = null;
        for (Node node : bucket) {
            if (node.key.equals(key)) {
                toRemove = node;
                break;
            }
        }
        if (toRemove != null) {
            bucket.remove(toRemove); // Remove node if key is found
        }
    }
    // Method to display the hash table
    public void display() {
        for (int i = 0; i < capacity; i++) {
            System.out.print("Bucket " + i + ": ");
            for (Node node : table[i]) {
                System.out.print("[" + node.key + "=" + node.value + "] ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        HashTable<String, String> hashTable = new HashTable<>(5);
        hashTable.put("John", "john@example.com");
        hashTable.put("Jane", "jane@example.com");
        hashTable.put("Jack", "jack@example.com");
        hashTable.put("Jill", "jill@example.com");
        hashTable.display();
        System.out.println("Get Jane: " + hashTable.get("Jane"));
        System.out.println("Get Jack: " + hashTable.get("Jack"));
        hashTable.remove("Jack");
        System.out.println("After removing Jack:");
        hashTable.display();
    }
}   

Output:

 
Bucket 0: [[email protected]] 
Bucket 1: 
Bucket 2: [[email protected]] [[email protected]] 
Bucket 3: 
Bucket 4: [[email protected]] 
Get Jane: [email protected]
Get Jack: [email protected]
After removing Jack:
Bucket 0: [[email protected]] 
Bucket 1: 
Bucket 2: [[email protected]] 
Bucket 3: 
Bucket 4: [[email protected]]

Conclusion

Implementing a hash table with separate chaining in Java demonstrates the practicality and efficiency of this data structure for handling key-value pairs. Our custom hash table class showcases how to manage collisions using linked lists, ensuring that multiple entries can coexist within the same bucket. By providing methods for insertion, retrieval, and deletion, along with a display function, this implementation highlights the key operations essential for a functional hash table.

Separate chaining offers a simple and effective solution for collision resolution, leveraging Java's LinkedList to maintain a straightforward structure. This method ensures that hash tables can handle varying load factors and maintain efficient operation even when multiple keys map to the same index.

Understanding and implementing hash tables with separate chaining equips developers with the tools to manage collections of data efficiently. This knowledge is foundational for more advanced data structures and algorithms, reinforcing core concepts in computer science and enhancing problem-solving skills. Through this implementation, we have explored the mechanics of hash tables, gained insight into collision handling, and demonstrated practical coding techniques in Java.

Next TopicIsland-of-isolation-in-java

← prev next →