{"id":7678,"date":"2025-05-29T13:21:58","date_gmt":"2025-05-29T13:21:58","guid":{"rendered":"https:\/\/msgprogramator.sk\/?p=7678"},"modified":"2026-04-01T11:54:45","modified_gmt":"2026-04-01T11:54:45","slug":"java-hashtable","status":"publish","type":"post","link":"https:\/\/msgprogramator.sk\/en\/java-hashtable\/","title":{"rendered":"HashTable – Java data structures"},"content":{"rendered":"

Java HashTable is a data structure that allows you to safely work with data even in multi-threaded applications. Although it is an older but still reliable implementation, its use has specific characteristics. In the following lines, we’ll look at how the HashTable class works, what its advantages and limitations are, and also when it makes sense to use it instead of more modern alternatives such as HashMap.<\/p>\n

The HashTable<\/strong> class is one of the older Java implementations of hash tables.<\/p>\n

\"HashTable<\/p>\n

HashTable<\/strong> collection – inheritance hierarchy <\/strong>(source: media.geeksforgeeks.org\/wp-content\/uploads\/20201124183400\/HierarchyofHashtable.png)<\/p>\n

<\/div>\n

HashTable in Java – data structure introduction<\/h2>\n

The HashTable<\/strong> class is an implementation of the Map<\/strong> interface that stores key-value pairs and uses a hash table for fast operations. Each key must be unique and can never be null<\/em>, nor can the value, so null values are not allowed in HashTable.<\/p>\n

Unlike more modern collections like HashMap<\/a>, HashTable is synchronized, which means it is safe for use in multithreaded applications, but at the same time its operations can be slower.<\/p>\n

Java<\/span>6 min.<\/span>\"Laptop<\/div>
28. 5. 2025<\/span><\/div>

HashMap – Java data structures<\/span><\/h3>
Learn about the HashMap data structure in Java - an overview of methods, operations, advantages, disadvantages and practical examples of its use. <\/div><\/div><\/div><\/a><\/div>\n

HashTable uses the hashCode()<\/em> method of objects to evenly divide pairs into internal \u201cbuckets\u201d. This allows to perform adding, searching and deleting operations in constant time (O(1)) with an ideal layout.<\/p>\n

HashTable – constructors<\/h2>\n

To create a HashTable instance, we have several constructors available:<\/p>\n

1. Empty HashTable<\/strong><\/p>\n

Creates an empty hash table with default capacity (11) and load factor (0.75).<\/p>\n

Hashtable<Integer, String> table = new Hashtable<>();<\/code><\/pre>\n
2.HashTable with defined capacity<\/strong><\/p>\n
Creates a new, empty hash table with the specified initial capacity and default load factor (0.75).<\/p>\n
Hashtable<Integer, String> table = new Hashtable<>(20);<\/code><\/p>\n
3. HashTable with defined capacity and load factor<\/strong><\/p>\n
Creates a new, empty hash table with the specified initial capacity and the specified load factor.<\/p>\n
Hashtable<Integer, String> table = new Hashtable<>(20, 0.82f);<\/code><\/pre>\n
4. HashTable constructed from Map<\/strong><\/p>\n
Creates a new hash table with the same mapping as the given Map.<\/p>\n
Hashtable(Map<? extends K,? extends V> t)<\/code><\/pre>\n
Initial capacity, Load Factor<\/h3>\n
The Hashtable instance has two parameters that affect its performance: initial capacity and load factor. The capacity is the number of segments in the hashtable, and the initial capacity is simply the capacity at the time the hashtable is created. In the case of the same hash node (called a hash collision), multiple records are stored in a single segment and must be searched sequentially. The load factor indicates how much the hash table can fill up before its capacity is automatically increased.<\/p>\n
In general, the default load factor (0.75) offers a good compromise between time and space costs. Higher values reduce the space overhead, but increase the time cost of retrieving a record (which is reflected in most hashtable operations, including get and put). Initial capacity manages the tradeoff between wasted space and the need for repeated operations that are time-consuming.<\/p>\n
If the initial capacity is greater than the maximum number of records the hash table will contain divided by its load factor, no rehash operations will ever occur. However, setting the initial capacity too high can waste space. Therefore, when constructing a HashTable, we recommend making the best estimate of how many elements we will store in the collection and choosing the correct initial capacity (and possibly load factor).<\/p>\n
If many records are to be created in a hashtable, creating it with a large enough capacity may allow records to be inserted more efficiently than having it perform automatic rehashing as needed to increase the capacity of the table.<\/p>\n
Hash Function<\/h3>\n
A well-designed hash function for objects (hashCode) is extremely important because it is what evenly distributes elements into the correct buckets, reducing the likelihood of collisions and maintaining the efficiency and performance of the collection.<\/p>\n
When inserting an element into the collection, its hash value is calculated and the segment where the element should be stored is determined. Of course, this is not enough because two objects with the same hashCode may not be the same, so within the same bucket, objects are compared using the equals()<\/em> method to ensure the uniqueness of the inserted elements.<\/p>\n
HashTable – basic operations<\/h2>\n
Some of the basic operations we can perform with HashTable include:<\/p>\n