What are the differences between a HashMap and a Hashtable in Java?

Created 02.09.2008 20:12
Viewed 1.6M times
3954 votes

What are the differences between a HashMap and a Hashtable in Java?

Which is more efficient for non-threaded applications?

2
Comments
HashTable is obsolete in Java 1.7 and it is recommended to use ConcurrentMap implementation by MissFiona, 09.04.2017 22:10
@MissFiona No, ConcurrentMap is not necessary here, as the Question says “non-threaded applications” meaning threading/concurrency is not an issue. by Basil Bourque, 29.12.2019 01:11
Answers 36
7
3943

There are several differences between HashMap and Hashtable in Java:

  1. Hashtable is synchronized, whereas HashMap is not. This makes HashMap better for non-threaded applications, as unsynchronized Objects typically perform better than synchronized ones.

  2. Hashtable does not allow null keys or values. HashMap allows one null key and any number of null values.

  3. One of HashMap's subclasses is LinkedHashMap, so in the event that you'd want predictable iteration order (which is insertion order by default), you could easily swap out the HashMap for a LinkedHashMap. This wouldn't be as easy if you were using Hashtable.

Since synchronization is not an issue for you, I'd recommend HashMap. If synchronization becomes an issue, you may also look at ConcurrentHashMap.

02.09.2008 23:02
Comments
If you want to make a HashMap thread-safe, use Collections.synchronizedMap(). by Rok Strniša, 22.11.2011 18:48
I would also comment that the naive approach to thread-safety in Hashtable ("synchronizing every method should take care of any concurrency problems!") makes it very much worse for threaded applications. You're better off externally synchronizing a HashMap (and thinking about the consequences), or using a ConcurrentMap implementation (and exploiting its extended API for concurrency). Bottom line: the only reason to use Hashtable is when a legacy API (from ca. 1996) requires it. by erickson, 16.03.2012 17:19
HashMap gives flexibility to programmer to write threadSafe code when they actually use it. It happened rarely that I needed a thread safe collection like ConcurrentHashMap or HashTable. What I needed is certain set of functions or certain statements in a synchronized block to be threadsafe. by Gaurava Agarwal, 27.06.2016 09:00
Hashtable is obsolete and we are using HashMap for non thread safe environment. If you need thread safety then you can use Collections.synchronizedMap() or use ConcurrentHashMap which is more efficient that hashtable. by Maneesh Kumar, 30.03.2018 03:45
It's obsolete but not deprecated and I'm wondering why this is. I'm guessing removing this class (and Vector for the same reasons) would break too much existing code and annotating with @Deprecated would imply an intention to remove the code, which apparently is not there. by Jilles van Gurp, 19.05.2018 08:11
You can also use ConcurrentSkipListMap (docs.oracle.com/javase/10/docs/api/java/util/concurrent/…). It is thread-safe collection similar to ConcurrentHashMap and this map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time. by rashid, 25.06.2018 07:25
HashTable use single intrinsic lock which result in very poor performance in even in low contention. While Threadsfe counterpart of HashMap i.e. ConcurrentHashMap use lock spliting which is user configurable has multitime better performance even in high contention. by Gajraj Tanwar, 03.05.2021 10:09
Show remaining 2 comments
6
717

Note, that a lot of the answers state that Hashtable is synchronised. In practice this buys you very little. The synchronization is on the accessor / mutator methods will stop two threads adding or removing from the map concurrently, but in the real world you will often need additional synchronisation.

A very common idiom is to "check then put" — i.e. look for an entry in the Map, and add it if it does not already exist. This is not in any way an atomic operation whether you use Hashtable or HashMap.

An equivalently synchronised HashMap can be obtained by:

Collections.synchronizedMap(myMap);

But to correctly implement this logic you need additional synchronisation of the form:

synchronized(myMap) {
    if (!myMap.containsKey("tomato"))
        myMap.put("tomato", "red");
}

Even iterating over a Hashtable's entries (or a HashMap obtained by Collections.synchronizedMap) is not thread safe unless you also guard the Map from being modified through additional synchronization.

Implementations of the ConcurrentMap interface (for example ConcurrentHashMap) solve some of this by including thread safe check-then-act semantics such as:

ConcurrentMap.putIfAbsent(key, value);
03.09.2008 11:00
Comments
Also note that if a HashMap is modified, iterators pointing to it are rendered invalid. by Chris K, 22.04.2009 22:03
So is there any difference between synchronized(myMap) {...} and ConcurrentHashMap in terms of thread safe? by telebog, 11.11.2011 16:48
Very true, I tried to explain same here..lovehasija.com/2012/08/16/… by Love Hasija, 20.09.2012 10:21
@Bhushan: It will throw on a best-effort basis, this is not guaranteed behavior: docs.oracle.com/javase/7/docs/api/java/util/HashMap.html by Matt Stephenson, 03.10.2013 18:49
Having been in the middle of a JVM development crew for a number of years I can state that Hashtable's internal synchronization is at least useful for properly pointing the finger at the customer's code when he writes dodgy concurrent code. We received several complaints of failures inside HashMap (and hence "obviously" a JDK/JVM bug), when the cause was concurrent modification. by Hot Licks, 20.08.2014 15:34
The implementation of Collections.synchronizedMap includes a synchronized putIfAbsent, so you don't need to use containsKey/put yourself. by A248, 07.01.2021 16:55
Show remaining 1 comments
6
380

Hashtable is considered legacy code. There's nothing about Hashtable that can't be done using HashMap or derivations of HashMap, so for new code, I don't see any justification for going back to Hashtable.

25.06.2009 01:46
Comments
From Hashtable javadoc (emphasis added): "As of the Java 2 platform v1.2, this class was retrofitted to implement the Map interface, making it a member of the Java Collections Framework." However, you are right that it is legacy code. All the benefits of synchronization can be obtained more efficiently with Collections.synchronizedMap(HashMap). (Similar to Vector being a legacy version of Collections.synchronizedList(ArrayList).) by Kip, 19.01.2010 22:09
@aberrant80: unfortunately you have no choice between the two and have to use Hashtable when programming for J2ME... by pwes, 12.01.2012 08:13
this answer should be deleted. it contains incorrect information and has a lot of upvotes. by anon58192932, 22.01.2016 20:40
@anon58192932 Is it possible to edit the question to fix it? by GC_, 14.10.2016 15:39
We have to get the attention of the poster @aberrant80 or an admin by flagging. Flagging could help - will try that now. by anon58192932, 14.10.2016 20:05
Agree that "Hashtable is considered legacy code". You should use ConcurentHashMap instead if you need concurrency. by MastAvalons, 17.06.2019 09:54
Show remaining 1 comments
5
203

This question is often asked in interview to check whether candidate understands correct usage of collection classes and is aware of alternative solutions available.

  1. The HashMap class is roughly equivalent to Hashtable, except that it is non synchronized and permits nulls. (HashMap allows null values as key and value whereas Hashtable doesn't allow nulls).
  2. HashMap does not guarantee that the order of the map will remain constant over time.
  3. HashMap is non synchronized whereas Hashtable is synchronized.
  4. Iterator in the HashMap is fail-safe while the enumerator for the Hashtable is not and throw ConcurrentModificationException if any other Thread modifies the map structurally by adding or removing any element except Iterator's own remove() method. But this is not a guaranteed behavior and will be done by JVM on best effort.

Note on Some Important Terms:

  1. Synchronized means only one thread can modify a hash table at one point of time. Basically, it means that any thread before performing an update on a Hashtable will have to acquire a lock on the object while others will wait for lock to be released.
  2. Fail-safe is relevant within the context of iterators. If an iterator has been created on a collection object and some other thread tries to modify the collection object "structurally", a concurrent modification exception will be thrown. It is possible for other threads though to invoke set method since it doesn't modify the collection "structurally". However, if prior to calling set, the collection has been modified structurally, IllegalArgumentException will be thrown.
  3. Structurally modification means deleting or inserting element which could effectively change the structure of map.

HashMap can be synchronized by

Map m = Collections.synchronizeMap(hashMap);

Map provides Collection views instead of direct support for iteration via Enumeration objects. Collection views greatly enhance the expressiveness of the interface, as discussed later in this section. Map allows you to iterate over keys, values, or key-value pairs; Hashtable does not provide the third option. Map provides a safe way to remove entries in the midst of iteration; Hashtable did not. Finally, Map fixes a minor deficiency in the Hashtable interface. Hashtable has a method called contains, which returns true if the Hashtable contains a given value. Given its name, you'd expect this method to return true if the Hashtable contained a given key, because the key is the primary access mechanism for a Hashtable. The Map interface eliminates this source of confusion by renaming the method containsValue. Also, this improves the interface's consistency — containsValue parallels containsKey.

The Map Interface

04.10.2011 06:39
Comments
This answer contains at least 2 significant factual inaccuracies. It certainly DOES NOT deserve this many upvotes. by Stephen C, 09.09.2013 08:05
1) HashMap's iterators are NOT fail-safe. They are fail-fast. There is a huge difference in meaning between those two terms. 2) There is no set operation on a HashMap. 3) The put(...) operation won't throw IllegalArgumentException if there was a previous change. 4) The fail-fast behaviour of HashMap also occurs if you change a mapping. 5) The fail-fast behaviour is guaranteed. (What is not guaranteed is the behaviour of a HashTable if you make a concurrent modification. The actual behaviour is ... unpredictable.) by Stephen C, 09.09.2013 08:14
6) Hashtable does not guarantee that the order of map elements will be stable over time either. (You are perhaps confusing Hashtable with LinkedHashMap.) by Stephen C, 09.09.2013 08:16
Anyone else really worried that students these days are getting the errant idea that getting "synchronized versions" of the collections somehow means that you don't have to externally synchronize compound operations? My favorite example of this being thing.set(thing.get() + 1); which more often than not catches newbies by surprise as completely unprotected, especially if the get() and set() are synchronized methods. Many of them are expecting magic. by User, 04.05.2015 22:26
Iterators on HashMap is not fail-safe by Abdul, 30.07.2018 01:56
2
135

HashMap: An implementation of the Map interface that uses hash codes to index an array. Hashtable: Hi, 1998 called. They want their collections API back.

Seriously though, you're better off staying away from Hashtable altogether. For single-threaded apps, you don't need the extra overhead of synchronisation. For highly concurrent apps, the paranoid synchronisation might lead to starvation, deadlocks, or unnecessary garbage collection pauses. Like Tim Howland pointed out, you might use ConcurrentHashMap instead.

02.09.2008 23:14
Comments
This actually makes sense. ConcurrentHashMaps gives you freedom of synchronization and debugging is lot more easier. by prap19, 19.11.2011 14:55
Is this specific to Java or all the hash map implementation. by User, 01.09.2018 19:23
0
131

Keep in mind that HashTable was legacy class before Java Collections Framework (JCF) was introduced and was later retrofitted to implement the Map interface. So was Vector and Stack.

Therefore, always stay away from them in new code since there always better alternative in the JCF as others had pointed out.

Here is the Java collection cheat sheet that you will find useful. Notice the gray block contains the legacy class HashTable,Vector and Stack.

enter image description here

25.03.2014 08:58
5
75

There is many good answer already posted. I'm adding few new points and summarizing it.

HashMap and Hashtable both are used to store data in key and value form. Both are using hashing technique to store unique keys. But there are many differences between HashMap and Hashtable classes that are given below.

HashMap

  1. HashMap is non synchronized. It is not-thread safe and can't be shared between many threads without proper synchronization code.
  2. HashMap allows one null key and multiple null values.
  3. HashMap is a new class introduced in JDK 1.2.
  4. HashMap is fast.
  5. We can make the HashMap as synchronized by calling this code
    Map m = Collections.synchronizedMap(HashMap);
  6. HashMap is traversed by Iterator.
  7. Iterator in HashMap is fail-fast.
  8. HashMap inherits AbstractMap class.

Hashtable

  1. Hashtable is synchronized. It is thread-safe and can be shared with many threads.
  2. Hashtable doesn't allow any null key or value.
  3. Hashtable is a legacy class.
  4. Hashtable is slow.
  5. Hashtable is internally synchronized and can't be unsynchronized.
  6. Hashtable is traversed by Enumerator and Iterator.
  7. Enumerator in Hashtable is not fail-fast.
  8. Hashtable inherits Dictionary class.

Further reading What is difference between HashMap and Hashtable in Java?

enter image description here

06.03.2017 10:09
Comments
Pretty much covered in this answer (dupicate of )- stackoverflow.com/a/39785829/432903. by prayagupd, 13.03.2017 02:36
Why do you say ~"Hashtable is a legacy class"? Where is the supporting documentation for that. by IgorGanapolsky, 24.03.2017 19:29
@IgorGanapolsky you may read this - stackoverflow.com/questions/21086307/… by roottraveller, 29.03.2017 09:48
Maintaining HashMap is costly than TreeMap. Because HashMap creates unnecessary extra buckets. by Abdul, 30.07.2018 02:05
A LinkedHashMap has a doubly-linked list of entries, not of buckets. Buckets are accessible via array indices and need not be linked. by thomas.schuerger, 04.02.2021 15:15
2
67

In addition to what izb said, HashMap allows null values, whereas the Hashtable does not.

Also note that Hashtable extends the Dictionary class, which as the Javadocs state, is obsolete and has been replaced by the Map interface.

02.09.2008 20:30
Comments
but that does not make the HashTable obsolete does it? by Pacerier, 01.11.2011 20:22
@Pacerier HashTable is obsolete since Java 1.7. by Majid Ali Khan, 23.05.2019 11:25
0
66

Take a look at this chart. It provides comparisons between different data structures along with HashMap and Hashtable. The comparison is precise, clear and easy to understand.

Java Collection Matrix

20.11.2012 05:35
0
51

Hashtable is similar to the HashMap and has a similar interface. It is recommended that you use HashMap, unless you require support for legacy applications or you need synchronisation, as the Hashtables methods are synchronised. So in your case as you are not multi-threading, HashMaps are your best bet.

02.09.2008 20:25
0
36

Another key difference between hashtable and hashmap is that Iterator in the HashMap is fail-fast while the enumerator for the Hashtable is not and throw ConcurrentModificationException if any other Thread modifies the map structurally by adding or removing any element except Iterator's own remove() method. But this is not a guaranteed behavior and will be done by JVM on best effort."

My source: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html

08.09.2011 06:40
0
36

Beside all the other important aspects already mentioned here, Collections API (e.g. Map interface) is being modified all the time to conform to the "latest and greatest" additions to Java spec.

For example, compare Java 5 Map iterating:

for (Elem elem : map.keys()) {
  elem.doSth();
}

versus the old Hashtable approach:

for (Enumeration en = htable.keys(); en.hasMoreElements(); ) {
  Elem elem = (Elem) en.nextElement();
  elem.doSth();
}

In Java 1.8 we are also promised to be able to construct and access HashMaps like in good old scripting languages:

Map<String,Integer> map = { "orange" : 12, "apples" : 15 };
map["apples"];

Update: No, they won't land in 1.8... :(

Are Project Coin's collection enhancements going to be in JDK8?

12.01.2012 09:17
0
35

Hashtable is synchronized, whereas HashMap isn't. That makes Hashtable slower than Hashmap.

For single thread applications, use HashMap since they are otherwise the same in terms of functionality.

02.09.2008 20:22
0
30
  • HashTable is synchronized, if you are using it in a single thread you can use HashMap, which is an unsynchronized version. Unsynchronized objects are often a little more performant. By the way if multiple threads access a HashMap concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally. Youn can wrap a unsynchronized map in a synchronized one using :

    Map m = Collections.synchronizedMap(new HashMap(...));
    
  • HashTable can only contain non-null object as a key or as a value. HashMap can contain one null key and null values.

  • The iterators returned by Map are fail-fast, if the map is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future. Whereas the Enumerations returned by Hashtable's keys and elements methods are not fail-fast.

  • HashTable and HashMap are member of the Java Collections Framework (since Java 2 platform v1.2, HashTable was retrofitted to implement the Map interface).

  • HashTable is considered legacy code, the documentation advise to use ConcurrentHashMap in place of Hashtable if a thread-safe highly-concurrent implementation is desired.

  • HashMap doesn't guarantee the order in which elements are returned. For HashTable I guess it's the same but I'm not entirely sure, I don't find ressource that clearly state that.

29.04.2012 13:57
0
30

HashMap and Hashtable have significant algorithmic differences as well. No one has mentioned this before so that's why I am bringing it up. HashMap will construct a hash table with power of two size, increase it dynamically such that you have at most about eight elements (collisions) in any bucket and will stir the elements very well for general element types. However, the Hashtable implementation provides better and finer control over the hashing if you know what you are doing, namely you can fix the table size using e.g. the closest prime number to your values domain size and this will result in better performance than HashMap i.e. less collisions for some cases.

Separate from the obvious differences discussed extensively in this question, I see the Hashtable as a "manual drive" car where you have better control over the hashing and the HashMap as the "automatic drive" counterpart that will generally perform well.

10.12.2012 08:57
3
29

Based on the info here, I'd recommend going with HashMap. I think the biggest advantage is that Java will prevent you from modifying it while you are iterating over it, unless you do it through the iterator.

02.09.2008 20:14
Comments
It doesn't actually prevent it, it just detects it and throws an error. by Bart van Heukelom, 18.12.2010 01:44
I'm pretty sure it will throw a ConncurrentModificationException before the underlying collection is modified, though I could be wrong. by pkaeding, 01.01.2011 01:46
It will attempt to detect concurrent modification and throw an exception. But if you're doing anything with threads, it can't make any promises. Absolutely anything can happen, including breakage. by cHao, 18.04.2011 14:03
0
25

A Collection — sometimes called a container — is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate data. A collections framework W is a unified architecture for representing and manipulating collections.

The HashMap JDK1.2 and Hashtable JDK1.0, both are used to represent a group of objects that are represented in <Key, Value> pair. Each <Key, Value> pair is called Entry object. The collection of Entries is referred by the object of HashMap and Hashtable. Keys in a collection must be unique or distinctive. [as they are used to retrieve a mapped value a particular key. values in a collection can be duplicated.]


« Superclass, Legacy and Collection Framework member

Hashtable is a legacy class introduced in JDK1.0, which is a subclass of Dictionary class. From JDK1.2 Hashtable is re-engineered to implement the Map interface to make a member of collection framework. HashMap is a member of Java Collection Framework right from the beginning of its introduction in JDK1.2. HashMap is the subclass of the AbstractMap class.

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

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { ... }

« Initial capacity and Load factor

The capacity is the number of buckets in the hash table, and the initial capacity is simply the capacity at the time the hash table is created. Note that the hash table is open: in the case of a "hashcollision", a single bucket stores multiple entries, which must be searched sequentially. The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased.

HashMap constructs an empty hash table with the default initial capacity (16) and the default load factor (0.75). Where as Hashtable constructs empty hashtable with a default initial capacity (11) and load factor/fill ratio (0.75).

Hash Map & Hashtable

« Structural modification in case of hash collision

HashMap, Hashtable in case of hash collisions they store the map entries in linked lists. From Java8 for HashMap if hash bucket grows beyond a certain threshold, that bucket will switch from linked list of entries to a balanced tree. which improve worst-case performance from O(n) to O(log n). While converting the list to binary tree, hashcode is used as a branching variable. If there are two different hashcodes in the same bucket, one is considered bigger and goes to the right of the tree and other one to the left. But when both the hashcodes are equal, HashMap assumes that the keys are comparable, and compares the key to determine the direction so that some order can be maintained. It is a good practice to make the keys of HashMap comparable. On adding entries if bucket size reaches TREEIFY_THRESHOLD = 8 convert linked list of entries to a balanced tree, on removing entries less than TREEIFY_THRESHOLD and at most UNTREEIFY_THRESHOLD = 6 will reconvert balanced tree to linked list of entries. Java 8 SRC, stackpost

« Collection-view iteration, Fail-Fast and Fail-Safe

    +--------------------+-----------+-------------+
    |                    | Iterator  | Enumeration |
    +--------------------+-----------+-------------+
    | Hashtable          | fail-fast |    safe     |
    +--------------------+-----------+-------------+
    | HashMap            | fail-fast | fail-fast   |
    +--------------------+-----------+-------------+
    | ConcurrentHashMap  |   safe    |   safe      |
    +--------------------+-----------+-------------+

Iterator is a fail-fast in nature. i.e it throws ConcurrentModificationException if a collection is modified while iterating other than it’s own remove() method. Where as Enumeration is fail-safe in nature. It doesn’t throw any exceptions if a collection is modified while iterating.

According to Java API Docs, Iterator is always preferred over the Enumeration.

NOTE: The functionality of Enumeration interface is duplicated by the Iterator interface. In addition, Iterator adds an optional remove operation, and has shorter method names. New implementations should consider using Iterator in preference to Enumeration.

In Java 5 introduced ConcurrentMap Interface: ConcurrentHashMap - a highly concurrent, high-performance ConcurrentMap implementation backed by a hash table. This implementation never blocks when performing retrievals and allows the client to select the concurrency level for updates. It is intended as a drop-in replacement for Hashtable: in addition to implementing ConcurrentMap, it supports all of the "legacy" methods peculiar to Hashtable.

  • Each HashMapEntrys value is volatile thereby ensuring fine grain consistency for contended modifications and subsequent reads; each read reflects the most recently completed update

  • Iterators and Enumerations are Fail Safe - reflecting the state at some point since the creation of iterator/enumeration; this allows for simultaneous reads and modifications at the cost of reduced consistency. They do not throw ConcurrentModificationException. However, iterators are designed to be used by only one thread at a time.

  • Like Hashtable but unlike HashMap, this class does not allow null to be used as a key or value.

public static void main(String[] args) {

    //HashMap<String, Integer> hash = new HashMap<String, Integer>();
    Hashtable<String, Integer> hash = new Hashtable<String, Integer>();
    //ConcurrentHashMap<String, Integer> hash = new ConcurrentHashMap<>();
    
    new Thread() {
        @Override public void run() {
            try {
                for (int i = 10; i < 20; i++) {
                    sleepThread(1);
                    System.out.println("T1 :- Key"+i);
                    hash.put("Key"+i, i);
                }
                System.out.println( System.identityHashCode( hash ) );
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();
    new Thread() {
        @Override public void run() {
            try {
                sleepThread(5);
                // ConcurrentHashMap  traverse using Iterator, Enumeration is Fail-Safe.
                
                // Hashtable traverse using Enumeration is Fail-Safe, Iterator is Fail-Fast.
                for (Enumeration<String> e = hash.keys(); e.hasMoreElements(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ e.nextElement());
                }
                
                // HashMap traverse using Iterator, Enumeration is Fail-Fast.
                /*
                for (Iterator< Entry<String, Integer> > it = hash.entrySet().iterator(); it.hasNext(); ) {
                    sleepThread(1);
                    System.out.println("T2 : "+ it.next());
                    // ConcurrentModificationException at java.util.Hashtable$Enumerator.next
                }
                */
                
                /*
                Set< Entry<String, Integer> > entrySet = hash.entrySet();
                Iterator< Entry<String, Integer> > it = entrySet.iterator();
                Enumeration<Entry<String, Integer>> entryEnumeration = Collections.enumeration( entrySet );
                while( entryEnumeration.hasMoreElements() ) {
                    sleepThread(1);
                    Entry<String, Integer> nextElement = entryEnumeration.nextElement();
                    System.out.println("T2 : "+ nextElement.getKey() +" : "+ nextElement.getValue() );
                    //java.util.ConcurrentModificationException at java.util.HashMap$HashIterator.nextNode
                    //                                          at java.util.HashMap$EntryIterator.next
                    //                                          at java.util.Collections$3.nextElement
                }
                */
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
    }.start();
    
    Map<String, String> unmodifiableMap = Collections.unmodifiableMap( map );
    try {
        unmodifiableMap.put("key4", "unmodifiableMap");
    } catch (java.lang.UnsupportedOperationException e) {
        System.err.println("UnsupportedOperationException : "+ e.getMessage() );
    }
}
static void sleepThread( int sec ) {
    try {
        Thread.sleep( 1000 * sec );
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

« Null Keys And Null Values

HashMap allows maximum one null key and any number of null values. Where as Hashtable doesn’t allow even a single null key and null value, if the key or value null is then it throws NullPointerException. Example

« Synchronized, Thread Safe

Hashtable is internally synchronized. Therefore, it is very much safe to use Hashtable in multi threaded applications. Where as HashMap is not internally synchronized. Therefore, it is not safe to use HashMap in multi threaded applications without external synchronization. You can externally synchronize HashMap using Collections.synchronizedMap() method.

« Performance

As Hashtable is internally synchronized, this makes Hashtable slightly slower than the HashMap.


@See

04.01.2018 11:58
0
18

For threaded apps, you can often get away with ConcurrentHashMap- depends on your performance requirements.

02.09.2008 22:38
0
17

1.Hashmap and HashTable both store key and value.

2.Hashmap can store one key as null. Hashtable can't store null.

3.HashMap is not synchronized but Hashtable is synchronized.

4.HashMap can be synchronized with Collection.SyncronizedMap(map)

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);
27.08.2014 11:29
0
16

Apart from the differences already mentioned, it should be noted that since Java 8, HashMap dynamically replaces the Nodes (linked list) used in each bucket with TreeNodes (red-black tree), so that even if high hash collisions exist, the worst case when searching is

O(log(n)) for HashMap Vs O(n) in Hashtable.

*The aforementioned improvement has not been applied to Hashtable yet, but only to HashMap, LinkedHashMap, and ConcurrentHashMap.

FYI, currently,

  • TREEIFY_THRESHOLD = 8 : if a bucket contains more than 8 nodes, the linked list is transformed into a balanced tree.
  • UNTREEIFY_THRESHOLD = 6 : when a bucket becomes too small (due to removal or resizing) the tree is converted back to linked list.
04.05.2016 15:04
0
14

There are 5 basic differentiations with HashTable and HashMaps.

  1. Maps allows you to iterate and retrieve keys, values, and both key-value pairs as well, Where HashTable don't have all this capability.
  2. In Hashtable there is a function contains(), which is very confusing to use. Because the meaning of contains is slightly deviating. Whether it means contains key or contains value? tough to understand. Same thing in Maps we have ContainsKey() and ContainsValue() functions, which are very easy to understand.
  3. In hashmap you can remove element while iterating, safely. where as it is not possible in hashtables.
  4. HashTables are by default synchronized, so it can be used with multiple threads easily. Where as HashMaps are not synchronized by default, so can be used with only single thread. But you can still convert HashMap to synchronized by using Collections util class's synchronizedMap(Map m) function.
  5. HashTable won't allow null keys or null values. Where as HashMap allows one null key, and multiple null values.
11.12.2013 12:45
1
9

HashMap and HashTable

  • Some important points about HashMap and HashTable. please read below details.

1) Hashtable and Hashmap implement the java.util.Map interface 2) Both Hashmap and Hashtable is the hash based collection. and working on hashing. so these are similarity of HashMap and HashTable.

  • What is the difference between HashMap and HashTable?

1) First difference is HashMap is not thread safe While HashTable is ThreadSafe
2) HashMap is performance wise better because it is not thread safe. while Hashtable performance wise is not better because it is thread safe. so multiple thread can not access Hashtable at the same time.

05.07.2014 06:27
Comments
Down-voted because this answer is not correct in some aspects. Hashtable does not implement the Map interface, but only extends the Dictionary class, which is obsolete. by Ioannis Sermetziadis, 25.10.2017 05:42
1
11

HashMap: It is a class available inside java.util package and it is used to store the element in key and value format.

Hashtable: It is a legacy class which is being recognized inside collection framework.

31.01.2013 13:41
Comments
If it is does so , it should be in comments not as answer. by manikant gautam, 16.10.2019 10:48
2
10
  1. Hashtable is synchronized whereas HashMap is not.
  2. Another difference is that iterator in the HashMap is fail-safe while the enumerator for the Hashtable isn't. If you change the map while iterating, you'll know.
  3. HashMap permits null values in it, while Hashtable doesn't.
22.01.2013 05:31
Comments
HashMap iterator is fail-fast not fail-safe. Thats why we have ConcurrentHashMap that allows modification while iteration. Check this post journaldev.com/122/… by Pankaj, 28.01.2013 21:13
@Pankaj Exactly. by Gaurav, 18.08.2020 12:22
0
13

My small contribution :

  1. First and most significant different between Hashtable and HashMap is that, HashMap is not thread-safe while Hashtable is a thread-safe collection.

  2. Second important difference between Hashtable and HashMap is performance, since HashMap is not synchronized it perform better than Hashtable.

  3. Third difference on Hashtable vs HashMap is that Hashtable is obsolete class and you should be using ConcurrentHashMap in place of Hashtable in Java.

18.03.2014 21:46
1
10

HashTable is a legacy class in the jdk that shouldn't be used anymore. Replace usages of it with ConcurrentHashMap. If you don't require thread safety, use HashMap which isn't threadsafe but faster and uses less memory.

15.04.2013 14:49
Comments
Because I thought the other answers, at the time, didn't dismiss HashTable but explained that it was threadsafe. The truth is that as soon as you see HashTable in code, you should replace it with ConcurrentHashMap without skipping a beat. And if thread safety is not a concern then HashMap can be used to improve performance a bit. by jontejj, 07.08.2015 08:29
1
3

HashMaps gives you freedom of synchronization and debugging is lot more easier

09.08.2012 12:28
Comments
What does ~"freedom of synchronization" mean? by IgorGanapolsky, 24.03.2017 19:03
0
8

Hashtable:

Hashtable is a data structure that retains values of key-value pair. It doesn’t allow null for both the keys and the values. You will get a NullPointerException if you add null value. It is synchronized. So it comes with its cost. Only one thread can access HashTable at a particular time.

Example :

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

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states= new Hashtable<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    //will throw NullPointerEcxeption at runtime

    System.out.println(states.get(1));
    System.out.println(states.get(2));
//  System.out.println(states.get(3));

    }
}

HashMap:

HashMap is like Hashtable but it also accepts key value pair. It allows null for both the keys and the values. Its performance better is better than HashTable, because it is unsynchronized.

Example:

import java.util.HashMap;
import java.util.Map;

public class TestClass {

    public static void main(String args[ ]) {
    Map<Integer,String> states = new HashMap<Integer,String>();
    states.put(1, "INDIA");
    states.put(2, "USA");

    states.put(3, null);    // Okay
    states.put(null,"UK");

    System.out.println(states.get(1));
    System.out.println(states.get(2));
    System.out.println(states.get(3));

    }
}
10.02.2015 07:44
1
8

HashMap and Hashtable both are used to store data in key and value form. Both are using hashing technique to store unique keys. ut there are many differences between HashMap and Hashtable classes that are given below.

enter image description here

30.10.2019 11:32
Comments
I think it is copied from javaconceptoftheday.com/… by user2485429, 23.03.2021 12:19
2
5

HashMap is emulated and therefore usable in GWT client code whereas Hashtable is not.

15.07.2013 09:54
Comments
Is that a comprehensive description of differences between the two apis? by IgorGanapolsky, 24.03.2017 19:04
Yes (sic!). That's all GWT developers need to know about it. by pong, 24.03.2017 19:41
1
5

Old and classic topic, just want to add this helpful blog that explains this:

http://blog.manishchhabra.com/2012/08/the-5-main-differences-betwen-hashmap-and-hashtable/

Blog by Manish Chhabra

The 5 main differences betwen HashMap and Hashtable

HashMap and Hashtable both implement java.util.Map interface but there are some differences that Java developers must understand to write more efficient code. As of the Java 2 platform v1.2, Hashtable class was retrofitted to implement the Map interface, making it a member of the Java Collections Framework.

  1. One of the major differences between HashMap and Hashtable is that HashMap is non-synchronized whereas Hashtable is synchronized, which means Hashtable is thread-safe and can be shared between multiple threads but HashMap cannot be shared between multiple threads without proper synchronization. Java 5 introduced ConcurrentHashMap which is an alternative of Hashtable and provides better scalability than Hashtable in Java.Synchronized means only one thread can modify a hash table at one point of time. Basically, it means that any thread before performing an update on a hashtable will have to acquire a lock on the object while others will wait for lock to be released.

  2. The HashMap class is roughly equivalent to Hashtable, except that it permits nulls. (HashMap allows null values as key and value whereas Hashtable doesn’t allow nulls).

  3. The third significant difference between HashMap vs Hashtable is that Iterator in the HashMap is a fail-fast iterator while the enumerator for the Hashtable is not and throw ConcurrentModificationException if any other Thread modifies the map structurally by adding or removing any element except Iterator’s own remove() method. But this is not a guaranteed behavior and will be done by JVM on best effort. This is also an important difference between Enumeration and Iterator in Java.

  4. One more notable difference between Hashtable and HashMap is that because of thread-safety and synchronization Hashtable is much slower than HashMap if used in Single threaded environment. So if you don’t need synchronization and HashMap is only used by one thread, it out perform Hashtable in Java.

  5. HashMap does not guarantee that the order of the map will remain constant over time.

Note that HashMap can be synchronized by

Map m = Collections.synchronizedMap(hashMap);

In Summary there are significant differences between Hashtable and HashMap in Java e.g. thread-safety and speed and based upon that only use Hashtable if you absolutely need thread-safety, if you are running Java 5 consider using ConcurrentHashMap in Java.

17.08.2014 09:58
Comments
ConcurrentHashMap is not read-synchronized, whereas Hashtable is. So if you have a high amount of read operations happening simultaneously with writes, a Hashtable would serve you better if you care about data integrity. by IgorGanapolsky, 24.03.2017 19:27
0
3

Since Hashtable in Java is a subclass of Dictionary class which is now obsolete due to the existence of Map Interface, it is not used anymore. Moreover, there isn't anything you can't do with a class that implements the Map Interface that you can do with a Hashtable.

07.03.2014 15:02
0
3

HashMap is a class used to store the element in key and value format.it is not thread safe. because it is not synchronized .where as Hashtable is synchronized.Hashmap permits null but hastable doesn't permit null.

23.07.2013 15:50
0
4

Synchronization or Thread Safe :

Hash Map is not synchronized hence it is not thred safe and it cannot be shared between multiple threads without proper synchronized block whereas, Hashtable is synchronized and hence it is thread safe.

Null keys and null values :

HashMap allows one null key and any number of null values.Hashtable does not allow null keys or values.

Iterating the values:

Iterator in the HashMap is a fail-fast iterator while the enumerator for the Hashtable is not and throw ConcurrentModificationException if any other Thread modifies the map structurally by adding or removing any element except Iterator’s own remove() method.

Superclass and Legacy :

HashMap is subclass of AbstractMap class whereas Hashtable is subclass of Dictionary class.

Performance :

As HashMap is not synchronized it is faster as compared to Hashtable.

Refer http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java for examples and interview questions and quiz related to Java collection

05.01.2016 18:35
0
0

The Hashtable class is synchronized, that is, it is designed to be used by applications that handle multiple or multithreaded process. Synchronized classes are less efficient in the classical case of an application to a process, so the Hashmap class is faster in general. The HashTable class does not accept the Null value, either for keys or for values, while the HashMap class allows a single key with Null and as many as null as possible.

21.04.2017 15:41
0
0

Hashtable is thread-safe and can be shared between multiple threads in the application.

On the other hand, HashMap is not synchronized and can't be accessed by multiple threads without additional synchronization code. We can use Collections.synchronizedMap() to make a thread-safe version of a HashMap. We can also just create custom lock code or make the code thread-safe by using the synchronized keyword.

HashMap is not synchronized, therefore it's faster and uses less memory than Hashtable. Generally, unsynchronized objects are faster than synchronized ones in a single threaded application.

Hashtable doesn't allow null at all.

We should use HashMap for an unsynchronized or single threaded application.

Since JDK 1.8, Hashtable has been deprecated. However, ConcurrentHashMap is a great Hashtable replacement. We should consider ConcurrentHashMap to use in applications with multiple threads.

12.03.2021 18:05