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

Question

What are the differences between a HashMap and a Hashtable in Java   Which is more efficient for non-threaded applications

User · Answer

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

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

Hashtable

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

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

User · Answer

My small contribution     First and most significant different between Hashtable and HashMap is that  HashMap is not thread-safe  while Hashtable is a thread-safe collection   Second important difference between Hashtable and HashMap is performance  since HashMap is not synchronized it perform better than Hashtable   Third difference on Hashtable vs HashMap is that Hashtable is obsolete class and you should be using ConcurrentHashMap in place of Hashtable in Java

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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 lt String Integer gt  map      orange    12   apples    15    map  apples      Update  No  they won t land in 1 8        Are Project Coin  39 s collection enhancements going to be in JDK8

User · Answer

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  lt Key  Value gt  pair  Each  lt Key  Value gt  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 lt K V gt  extends Dictionary lt K V gt  implements Map lt K V gt   Cloneable  Serializable          public class HashMap lt K V gt  extends AbstractMap lt K V gt  implements Map lt K V gt   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  quot hash collision quot   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       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  quot legacy quot  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 lt String  Integer gt  hash   new HashMap lt String  Integer gt         Hashtable lt String  Integer gt  hash   new Hashtable lt String  Integer gt           ConcurrentHashMap lt String  Integer gt  hash   new ConcurrentHashMap lt  gt              new Thread              Override public void run                 try                   for  int i   10  i  lt  20  i                          sleepThread 1                       System out println  quot T1  - Key quot  i                       hash put  quot Key quot  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 lt String gt  e   hash keys    e hasMoreElements                            sleepThread 1                       System out println  quot T2    quot   e nextElement                                                           HashMap traverse using Iterator  Enumeration is Fail-Fast                                     for  Iterator lt  Entry lt String  Integer gt   gt  it   hash entrySet   iterator    it hasNext                            sleepThread 1                       System out println  quot T2    quot   it next                            ConcurrentModificationException at java util Hashtable Enumerator next                                                                                          Set lt  Entry lt String  Integer gt   gt  entrySet   hash entrySet                    Iterator lt  Entry lt String  Integer gt   gt  it   entrySet iterator                    Enumeration lt Entry lt String  Integer gt  gt  entryEnumeration   Collections enumeration  entrySet                    while  entryEnumeration hasMoreElements                           sleepThread 1                       Entry lt String  Integer gt  nextElement   entryEnumeration nextElement                        System out println  quot T2    quot   nextElement getKey     quot     quot   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 lt String  String gt  unmodifiableMap   Collections unmodifiableMap  map        try           unmodifiableMap put  quot key4 quot    quot unmodifiableMap quot          catch  java lang UnsupportedOperationException e            System err println  quot UnsupportedOperationException    quot   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  A red   black tree is a kind of self-balancing binary search tree Performance Improvement for HashMap in Java 8

User · Answer

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

User · Answer

Hashtable is synchronized whereas HashMap is not  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  HashMap permits null values in it  while Hashtable doesn t

User · Answer

There are several differences between HashMap and Hashtable in Java    Hashtable is synchronized  whereas HashMap is not  This makes HashMap better for non-threaded applications  as unsynchronized Objects typically perform better than synchronized ones  Hashtable does not allow null keys or values   HashMap allows one null key and any number of null values  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

User · Answer

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

User · Answer

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

User · Answer

This question is often asked in interview to check whether candidate understands correct usage of collection classes and is aware of alternative solutions available    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   HashMap does not guarantee that the order of the map will remain constant over time  HashMap is non synchronized whereas Hashtable is synchronized  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    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  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  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

User · Answer

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

User · Answer

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 lt Integer String gt  states  new Hashtable lt Integer String gt         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 lt Integer String gt  states   new HashMap lt Integer String gt         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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

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

User · Answer

There are 5 basic differentiations with HashTable and HashMaps     Maps allows you to iterate and retrieve keys  values  and both key-value pairs as well  Where HashTable don t have all this capability   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   In hashmap you can remove element while iterating  safely  where as it is not possible in hashtables  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  HashTable won t allow null keys or null values  Where as HashMap allows one null key  and multiple null values

User · Answer

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

User · Answer

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          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    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     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    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    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

User · Answer

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

User · Answer

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

User · Answer

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

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

Examples related to java

Examples related to collections

Examples related to hashmap

Examples related to hashtable