Java Hashtable

Introduction

Hashtable in Java is part of the Java Collections Framework and implements the Map interface. It is a data structure that uses a hash table for storage, allowing for the mapping of keys to values. Hashtable is synchronized, making it thread-safe for use in concurrent applications, but it does not allow null keys or values.

Table of Contents

1. What is Hashtable?
2. Key Points About Hashtable
3. Creating a Hashtable and Adding Elements
4. Accessing Elements in a Hashtable
5. Modifying Elements in a Hashtable
6. Removing Elements from a Hashtable
7. Iterating Over a Hashtable
8. Searching for Elements in a Hashtable
9. Hashtable of User-Defined Objects
10. Common Hashtable Methods
11. Difference Between Hashtable and HashMap
12. Conclusion

1. What is Hashtable?

A Hashtable is a collection that stores key-value pairs in a hash table. It provides synchronization, making it thread-safe for concurrent access. Unlike HashMap, Hashtable does not allow null keys or values.

2. Key Points About Hashtable

• Key-Value Pairs: Stores data in key-value pairs.
• Null Keys and Values: Does not allow null keys or values.
• Order: Does not maintain any specific order of elements.
• Hashing: Uses hash table for storage.
• Performance: Provides constant-time performance for basic operations like put and get, assuming the hash function disperses the elements properly among the buckets.
• Synchronized: Thread-safe for concurrent access.

3. Creating a Hashtable and Adding Elements

To create a Hashtable, you can use the Hashtable constructor. You can then use methods such as put to add key-value pairs to the table.

Example:

In this example, we create a Hashtable of strings and integers and add a few key-value pairs to it.

import java.util.Hashtable;
import java.util.Map;

public class HashtableExample {
    public static void main(String[] args) {
        // Creating a Hashtable
        Map<String, Integer> table = new Hashtable<>();

        // Adding elements to the Hashtable
        table.put("Apple", 1);
        table.put("Banana", 2);
        table.put("Cherry", 3);
        // table.put(null, 4); // Null key (uncommenting this line will throw a NullPointerException)
        // table.put("Date", null); // Null value (uncommenting this line will throw a NullPointerException)

        // Displaying the Hashtable
        System.out.println("Hashtable: " + table);
    }
}

Output:

Hashtable: {Apple=1, Banana=2, Cherry=3}

4. Accessing Elements in a Hashtable

You can access elements in a Hashtable using the get method by providing the key.

Example:

In this example, we demonstrate how to access elements in a Hashtable.

import java.util.Hashtable;
import java.util.Map;

public class AccessHashtable {
    public static void main(String[] args) {
        // Creating a Hashtable
        Map<String, Integer> table = new Hashtable<>();
        table.put("Apple", 1);
        table.put("Banana", 2);
        table.put("Cherry", 3);

        // Accessing elements
        System.out.println("Value for 'Banana': " + table.get("Banana"));
        System.out.println("Value for 'Mango': " + table.get("Mango")); // Key not present
    }
}

Output:

Value for 'Banana': 2
Value for 'Mango': null

5. Modifying Elements in a Hashtable

You can modify elements in a Hashtable using the put method, which will replace the value for the given key if it already exists.

Example:

In this example, we demonstrate how to modify elements in a Hashtable.

import java.util.Hashtable;
import java.util.Map;

public class ModifyHashtable {
    public static void main(String[] args) {
        // Creating a Hashtable
        Map<String, Integer> table = new Hashtable<>();
        table.put("Apple", 1);
        table.put("Banana", 2);
        table.put("Cherry", 3);

        // Modifying an element
        table.put("Banana", 4); // Updating value for key "Banana"

        // Displaying the updated Hashtable
        System.out.println("Updated Hashtable: " + table);
    }
}

Output:

Updated Hashtable: {Apple=1, Banana=4, Cherry=3}

6. Removing Elements from a Hashtable

You can remove elements from a Hashtable using methods such as remove and clear.

Example:

In this example, we demonstrate how to remove elements from a Hashtable.

import java.util.Hashtable;
import java.util.Map;

public class RemoveHashtable {
    public static void main(String[] args) {
        // Creating a Hashtable
        Map<String, Integer> table = new Hashtable<>();
        table.put("Apple", 1);
        table.put("Banana", 2);
        table.put("Cherry", 3);

        // Removing an element
        table.remove("Banana");

        // Displaying the Hashtable after removal
        System.out.println("Hashtable after removal: " + table);

        // Clearing the Hashtable
        table.clear();
        System.out.println("Hashtable after clearing: " + table);
    }
}

Output:

Hashtable after removal: {Apple=1, Cherry=3}
Hashtable after clearing: {}

7. Iterating Over a Hashtable

You can iterate over a Hashtable using various methods such as a simple for-each loop, entrySet, and keySet.

Example:

In this example, we demonstrate different ways to iterate over a Hashtable.

import java.util.Hashtable;
import java.util.Map;

public class IterateHashtable {
    public static void main(String[] args) {
        // Creating a Hashtable
        Map<String, Integer> table = new Hashtable<>();
        table.put("Apple", 1);
        table.put("Banana", 2);
        table.put("Cherry", 3);

        // Using for-each loop with entrySet
        System.out.println("Using for-each loop with entrySet:");
        for (Map.Entry<String, Integer> entry : table.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // Using for-each loop with keySet
        System.out.println("Using for-each loop with keySet:");
        for (String key : table.keySet()) {
            System.out.println(key + ": " + table.get(key));
        }

        // Using forEach method (Java 8 and later)
        System.out.println("Using forEach method:");
        table.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

Output:

Using for-each loop with entrySet:
Apple: 1
Banana: 2
Cherry: 3
Using for-each loop with keySet:
Apple: 1
Banana: 2
Cherry: 3
Using forEach method:
Apple: 1
Banana: 2
Cherry: 3

8. Searching for Elements in a Hashtable

You can search for elements in a Hashtable using methods such as containsKey and containsValue.

Example:

In this example, we demonstrate how to check if a Hashtable contains a specific key or value.

import java.util.Hashtable;
import java.util.Map;

public class SearchHashtable {
    public static void main(String[] args) {
        // Creating a Hashtable
        Map<String, Integer> table = new Hashtable<>();
        table.put("Apple", 1);
        table.put("Banana", 2);
        table.put("Cherry", 3);

        // Check if the Hashtable contains a specific key
        System.out.println("Does the Hashtable contain 'Banana'? " + table.containsKey("Banana"));
        System.out.println("Does the Hashtable contain 'Mango'? " + table.containsKey("Mango"));

        // Check if the Hashtable contains a specific value
        System.out.println("Does the Hashtable contain value 3? " + table.containsValue(3));
        System.out.println("Does the Hashtable contain value 4? " + table.containsValue(4));
    }
}

Output:

Does the Hashtable contain 'Banana'? true
Does the Hashtable contain 'Mango'? false
Does the Hashtable contain value 3? true
Does the Hashtable contain value 4? false

9. Hashtable of User-Defined Objects

You can use Hashtable to store user-defined objects as keys or values. This involves creating a class for the objects you want to store and ensuring that the equals and hashCode methods are properly overridden for keys.

Example:

In this example, we create a Person class and then create a Hashtable to store Person objects as keys.

import java.util.Hashtable;
import java.util.Map;
import java.util.Objects;

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class UserDefinedObjectHashtable {
    public static void main(String[] args) {
        // Creating a Hashtable with Person objects as keys
        Map<Person, String> table = new Hashtable<>();
        table.put(new Person("Alice", 30), "Engineer");
        table.put(new Person("Bob", 25), "Designer");
        table.put(new Person("Charlie", 35), "Manager");

        // Displaying the Hashtable
        for (Map.Entry<Person, String> entry : table.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Output:

Person{name='Alice', age=30}: Engineer
Person{name='Bob', age=25}: Designer
Person{name='Charlie', age=35}: Manager

10. Common Hashtable() Methods

Adding Elements

• put(K key, V value): Associates the specified value with the specified key in the table.

Removing Elements

• remove(Object key): Removes the mapping for the specified key from the table if present.
• clear(): Removes all of the mappings from the table.

Accessing Elements

• get(Object key): Returns the value to which the specified key is mapped, or null if this table contains no mapping for the key.
• containsKey(Object key): Returns true if this table contains a mapping for the specified key.
• containsValue(Object value): Returns true if this table maps one or more keys to the specified value.
• size(): Returns the number of key-value mappings in the table.
• isEmpty(): Returns true if the table contains no key-value mappings.

Iterating

• entrySet(): Returns a Set view of the mappings contained in this table.
• keySet(): Returns a Set view of the keys contained in this table.
• values(): Returns a Collection view of the values contained in this table.

11. Difference Between Hashtable and HashMap

12. Conclusion

Hashtable is a versatile and thread-safe data structure in Java that provides a way to store key-value pairs with fast access and retrieval. It does not allow null keys or values and offers constant-time performance for basic operations. Understanding how to create, manipulate, and iterate over Hashtable can help you effectively manage collections of key-value pairs in your Java applications. With methods for adding, removing, accessing, and searching elements, Hashtable offers a comprehensive solution for managing maps of data in concurrent environments.

By using Hashtable, you can ensure that your collections are thread-safe, making it suitable for multi-threaded applications. However, for single-threaded contexts or where null keys/values are needed, HashMap might be a better choice due to its higher performance and flexibility.