Diferenças entre HashMap e Hashtable?

Quais são as diferenças entre um HashMap e uma Hashtable em Java?

Qual é mais eficiente para aplicativos não encadeados?

   

    Existem várias diferenças entre HashMap e Hashtable em Java:

    1. Hashtable é sincronizado , enquanto HashMap não é. Isso torna o HashMap melhor para aplicativos não encadeados, já que os Objetos não sincronizados normalmente têm um desempenho melhor que os sincronizados.

    2. Hashtable não permite chaves ou valores null . HashMap permite uma chave null e qualquer número de valores null .

    3. Uma das subclasss do HashMap é LinkedHashMap , portanto, caso você deseje uma ordem de iteração previsível (que é a ordem de inserção por padrão), é possível trocar facilmente o HashMap por um LinkedHashMap . Isso não seria tão fácil se você estivesse usando o Hashtable .

    Como a synchronization não é um problema para você, eu recomendo o HashMap . Se a synchronization se tornar um problema, você também poderá consultar o ConcurrentHashMap .

    Note que muitas das respostas indicam que o Hashtable está sincronizado. Na prática, isso te compra muito pouco. A synchronization está nos methods accessor / mutator para impedir que dois encadeamentos sejam adicionados ou removidos do mapa simultaneamente, mas no mundo real você frequentemente precisará de synchronization adicional.

    Um idioma muito comum é “verificar e depois colocar” – ou seja, procurar uma input no Mapa e adicioná-la se ela ainda não existir. Esta não é de forma alguma uma operação atômica, quer você use Hashtable ou HashMap.

    Um HashMap equivalentemente sincronizado pode ser obtido por:

     Collections.synchronizedMap(myMap); 

    Mas, para implementar corretamente essa lógica, você precisa de synchronization adicional do formulário:

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

    Mesmo iterar sobre as inputs de uma Hashtable (ou um HashMap obtido pelo Collections.synchronizedMap) não é thread safe, a menos que você também proteja o Map seja modificado através de synchronization adicional.

    As implementações da interface ConcurrentMap (por exemplo, ConcurrentHashMap ) resolvem algumas delas incluindo a semântica de verificação e ação com segurança de thread , como:

     ConcurrentMap.putIfAbsent(key, value); 

    Hashtable é considerado código legado. Não há nada sobre o Hashtable que não possa ser feito usando o HashMap ou derivações do HashMap , portanto, para o novo código, não vejo nenhuma justificativa para voltar ao Hashtable .

    Essa pergunta é frequentemente feita em entrevistas para verificar se o candidato compreende o uso correto das aulas de coleta e está ciente das soluções alternativas disponíveis.

    1. A class HashMap é aproximadamente equivalente a Hashtable, exceto que não é sincronizada e permite valores nulos. (HashMap permite valores nulos como chave e valor, enquanto Hashtable não permite nulos).
    2. O HashMap não garante que a ordem do mapa permaneça constante ao longo do tempo.
    3. O HashMap não é sincronizado, enquanto o Hashtable é sincronizado.
    4. Iterator no HashMap é à prova de falhas enquanto o enumerador da Hashtable não está e lança ConcurrentModificationException se qualquer outro Thread modifica estruturalmente o mapa adicionando ou removendo qualquer elemento exceto o próprio método remove () do Iterador. Mas isso não é um comportamento garantido e será feito pela JVM no melhor esforço.

    Nota sobre alguns termos importantes

    1. Sincronizado significa que apenas um thread pode modificar uma tabela de hash em um determinado momento. Basicamente, isso significa que qualquer thread antes de executar uma atualização em um hashtable terá que adquirir um bloqueio no object enquanto outros aguardarão o bloqueio ser liberado.
    2. Fail-safe é relevante a partir do contexto de iteradores. Se um iterador tiver sido criado em um object de coleção e algum outro thread tentar modificar o object de coleção “estruturalmente”, uma exceção de modificação simultânea será lançada. É possível que outros threads invoquem o método “set”, já que ele não modifica a coleção “estruturalmente”. No entanto, se antes de chamar “set”, a coleção foi modificada estruturalmente, “IllegalArgumentException” será lançada.
    3. Estruturalmente, modificar significa excluir ou inserir elementos que poderiam efetivamente alterar a estrutura do mapa.

    HashMap pode ser sincronizado por

    Map m = Collections.synchronizeMap(hashMap);

    O mapa fornece visualizações de coleção em vez de suporte direto para iteração por meio de objects de enumeração. As visualizações de coleção aumentam muito a expressividade da interface, conforme discutido mais adiante nesta seção. Mapa permite que você faça iterações sobre chaves, valores ou pares de valores-chave; Hashtable não fornece a terceira opção. O mapa fornece uma maneira segura de remover inputs no meio da iteração; Hashtable não. Finalmente, o Map corrige uma pequena deficiência na interface Hashtable. Hashtable possui um método chamado contains, que retorna true se a Hashtable contiver um determinado valor. Dado seu nome, você esperaria que este método retornasse true se a Hashtable continha uma dada chave, porque a chave é o mecanismo de access primário para uma Hashtable. A interface Map elimina essa fonte de confusão, renomeando o método containsValue. Além disso, isso melhora a consistência da interface – containsValue parallels containsKey.

    A interface do mapa

    HashMap : Uma implementação da interface Map que usa códigos hash para indexar uma matriz. Hashtable : Oi, 1998 chamado. Eles querem sua API de collections de volta.

    Falando sério, é melhor você ficar longe da Hashtable . Para aplicativos de segmentação única, você não precisa da sobrecarga extra de synchronization. Para aplicativos altamente simultâneos, a synchronization paranóica pode levar a inanição, impasses ou pausas desnecessárias na garbage collection. Como Tim Howland apontou, você pode usar ConcurrentHashMap .

    Tenha em mente que o HashTable era uma class legada antes do Java Collections Framework (JCF) ser introduzido e posteriormente adaptado para implementar a interface Map . Então foi Vector e Stack .

    Portanto, fique sempre longe deles em código novo, já que há sempre uma alternativa melhor no JCF, como outros apontaram.

    Aqui está a folha de dicas da coleção Java que você achará útil. Observe que o bloco cinza contém a class herdada HashTable, Vector e Stack.

    insira a descrição da imagem aqui

    Além do que izb disse, o HashMap permite valores nulos, enquanto o Hashtable não.

    Observe também que Hashtable estende a class Dictionary , que, como o estado Javadocs , é obsoleta e foi substituída pela interface Map .

    Dê uma olhada neste gráfico. Ele fornece comparações entre diferentes estruturas de dados, juntamente com o HashMap e o Hashtable. A comparação é precisa, clara e fácil de entender.

    Matriz de Coleção Java

    Hashtable é semelhante ao HashMap e tem uma interface semelhante. É recomendável usar o HashMap , a menos que você precise de suporte para aplicativos legados ou precise de synchronization, pois os methods do Hashtables são sincronizados. Então, no seu caso, como você não é multi-threading, HashMaps são a sua melhor aposta.

    Há muitas boas respostas já postadas. Estou adicionando alguns novos pontos e resumindo isso.

    HashMap e Hashtable são usados ​​para armazenar dados no formato de chave e valor . Ambos estão usando a técnica de hashing para armazenar chaves exclusivas. Mas existem muitas diferenças entre as classs HashMap e Hashtable que são dadas abaixo.

    HashMap

    1. HashMap não é sincronizado. Não é thread-safe e não pode ser compartilhado entre muitos threads sem o código de synchronization adequado.
    2. HashMap permite uma chave nula e vários valores nulos.
    3. HashMap é uma nova class introduzida no JDK 1.2.
    4. HashMap é rápido.
    5. Nós podemos fazer o HashMap como sincronizado chamando este código
      Map m = Collections.synchronizedMap(HashMap);
    6. HashMap é percorrido pelo Iterator.
    7. Iterator no HashMap é fail-fast.
    8. HashMap herda a class AbstractMap.

    Hashtable

    1. Hashtable é sincronizado. É thread-safe e pode ser compartilhado com muitos segmentos.
    2. Hashtable não permite nenhuma chave ou valor nulo.
    3. Hashtable é uma class legada.
    4. Hashtable é lento.
    5. Hashtable é sincronizada internamente e não pode ser desassociada.
    6. Hashtable é percorrido pelo enumerador e Iterator.
    7. O enumerador na Hashtable não é fail-fast.
    8. Hashtable herda class Dictionary.

    Leitura adicional Qual é a diferença entre HashMap e Hashtable em Java?

    insira a descrição da imagem aqui

    Outra diferença chave entre hashtable e hashmap é que Iterator no HashMap é fail-rápido enquanto o enumerador para a Hashtable não está e lança ConcurrentModificationException se qualquer outro Thread modifica estruturalmente o mapa adicionando ou removendo qualquer elemento exceto o método remove () do Iterator. Mas isso não é um comportamento garantido e será feito pela JVM no melhor esforço “.

    Minha fonte: http://javarevisited.blogspot.com/2010/10/difference-between-hashmap-and.html

    Além de todos os outros aspectos importantes já mencionados aqui, a API Collections (por exemplo, interface de mapa) está sendo modificada o tempo todo para se adequar às adições “mais recentes e maiores” às especificações de Java.

    Por exemplo, compare a iteração do Java 5 Map:

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

    versus a antiga abordagem Hashtable:

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

    No Java 1.8, também estamos prometidos para poder construir e acessar o HashMaps como nas boas e antigas linguagens de script:

     Map map = { "orange" : 12, "apples" : 15 }; map["apples"]; 

    Atualização: Não, eles não vão pousar em 1,8 … 🙁

    Os aprimoramentos da coleção do Project Coin serão no JDK8?

    • HashTable é sincronizado, se você estiver usando em um único segmento, você pode usar o HashMap , que é uma versão não sincronizada. Objetos não sincronizados costumam ter um pouco mais de desempenho. A propósito, se vários encadeamentos acessarem um HashMap simultaneamente e pelo menos um dos encadeamentos modificar o mapa estruturalmente, ele deverá ser sincronizado externamente. Youn pode envolver um mapa não sincronizado em um sincronizado usando:

       Map m = Collections.synchronizedMap(new HashMap(...)); 
    • HashTable só pode conter um object não nulo como uma chave ou como um valor. O HashMap pode conter uma chave nula e valores nulos.

    • Os iteradores retornados pelo Map são fail-fast, se o mapa for estruturalmente modificado a qualquer momento após a criação do iterador, de qualquer forma, exceto pelo próprio método remove do iterador, o iterador lançará um ConcurrentModificationException . Assim, em face da modificação concorrente, o iterador falha rapidamente e de forma limpa, em vez de arriscar um comportamento arbitrário e não determinístico em um tempo indeterminado no futuro. Considerando que as Enumerações retornadas pelos methods de chaves e elementos do Hashtable não são fail-fast.

    • HashTable e HashMap são membros do Java Collections Framework (desde a plataforma Java 2 v1.2, o HashTable foi adaptado para implementar a interface Map).

    • HashTable é considerado código legado, a documentação aconselha a usar ConcurrentHashMap no lugar de Hashtable se uma implementação altamente concorrente segura para thread for desejada.

    • O HashMap não garante a ordem em que os elementos são retornados. Para o HashTable, acho que é o mesmo, mas não tenho certeza, não encontro resources que indiquem claramente isso.

    HashMap e o Hashtable possuem diferenças algorítmicas significativas. Ninguém mencionou isso antes, então é por isso que estou falando sobre isso. HashMap irá construir uma tabela de hash com potência de dois tamanhos, aumentá-lo dinamicamente de forma que você tenha no máximo cerca de oito elementos (colisões) em qualquer bucket e agite os elementos muito bem para os tipos de elementos gerais. No entanto, a implementação do Hashtable fornece melhor controle sobre o hashing se você sabe o que está fazendo, ou seja, você pode corrigir o tamanho da tabela usando o número primo mais próximo ao tamanho do seu domínio de valores e isso resultará em melhor desempenho do que o HashMap. colisões para alguns casos.

    Separado das diferenças óbvias discutidas extensivamente nesta questão, eu vejo o Hashtable como um carro de “movimentação manual” onde você tem melhor controle sobre o hashing e o HashMap como a contraparte de “drive automático” que geralmente terá um bom desempenho.

    Hashtable é sincronizado, enquanto HashMap não é. Isso torna o Hashtable mais lento que o Hashmap.

    Para aplicativos não segmentados, use o HashMap, pois eles são os mesmos em termos de funcionalidade.

    Com base nas informações aqui , recomendo ir com o HashMap. Eu acho que a maior vantagem é que o Java irá impedi-lo de modificá-lo enquanto você estiver iterando sobre ele, a menos que você o faça através do iterador.

    Para aplicativos encadeados, muitas vezes você pode se safar com o ConcurrentHashMap – depende dos seus requisitos de desempenho.

    Uma Collection – às vezes chamada de container – é simplesmente um object que agrupa vários elementos em uma única unidade. Collection s são usadas para armazenar, recuperar, manipular e comunicar dados agregados. Uma estrutura de collections W é uma arquitetura unificada para representar e manipular collections.

    O HashMap JDK1.2 e Hashtable JDK1.0 , ambos são usados ​​para representar um grupo de objects que são representados no par . Cada par de é chamado de object Entry . A coleção de Entradas é referida pelo object de HashMap e Hashtable . As chaves de uma coleção devem ser únicas ou distintas. [como eles são usados ​​para recuperar um valor mapeado, uma chave particular. valores em uma coleção podem ser duplicados.]


    « Membro do Superclass, Legacy and Collection Framework

    Hashtable é uma class legada introduzida no JDK1.0 , que é uma subclass da class Dictionary. A partir do JDK1.2 Hashtable é reprojetado para implementar a interface Map para tornar um membro da estrutura de coleta. O HashMap é um membro do Java Collection Framework desde o início de sua introdução no JDK1.2 . HashMap é a subclass da class AbstractMap.

     public class Hashtable extends Dictionary implements Map, Cloneable, Serializable { ... } public class HashMap extends AbstractMap implements Map, Cloneable, Serializable { ... } 

    « Capacidade inicial e fator de carga

    A capacidade é o número de depósitos na tabela de hash e a capacidade inicial é simplesmente a capacidade no momento em que a tabela de hash é criada. Observe que a tabela de hash está aberta: no caso de uma ” collision hash “, um único depósito armazena várias inputs, que devem ser pesquisadas sequencialmente. O fator de carga é uma medida de como a tabela hash é permitida antes que sua capacidade seja aumentada automaticamente.

    O HashMap constrói uma tabela de hash vazia com a capacidade inicial padrão (16) e o fator de carga padrão (0,75). Onde como Hashtable constrói um hashtable vazio com uma capacidade inicial padrão (11) e uma taxa de fator de carga / preenchimento (0,75).

    Hash Map e Hashtable

    « Modificação estrutural em caso de colisão de hash

    HashMap , Hashtable , no caso de colisões de hash, armazenam as inputs do mapa em listas vinculadas. A partir do Java8 para HashMap se o bucket de hash aumentar além de um determinado limite, esse bucket alternará da linked list of entries to a balanced tree . que melhoram o desempenho do pior caso de O (n) para O (log n). Ao converter a lista em tree binária, o hashcode é usado como uma variável de ramificação. Se houver dois hashcodes diferentes no mesmo bucket, um é considerado maior e vai para a direita da tree e outro para a esquerda. Mas quando ambos os hashcodes são iguais, HashMap assume que as chaves são comparáveis ​​e compara a chave para determinar a direção para que alguma ordem possa ser mantida. É uma boa prática tornar as chaves do HashMap comparáveis . Ao adicionar inputs se o tamanho do depósito atingir TREEIFY_THRESHOLD = 8 converter a linked list de inputs em uma tree balanceada, removendo inputs menores que TREEIFY_THRESHOLD e, no máximo, UNTREEIFY_THRESHOLD = 6 reconverterá a tree balanceada para a linked list de inputs. Java 8 SRC , stackpost

    « Iteração de visualização de coleção, fail-fast e fail-safe

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

    Iterator é uma falha na natureza. isto é, ele lança ConcurrentModificationException se uma coleção é modificada enquanto iterando um método diferente de remove (). Onde como Enumeration é à prova de falhas na natureza. Ele não lança nenhuma exceção se uma coleção é modificada durante a iteração.

    De acordo com o Java API Docs, o Iterator é sempre preferido em relação à Enumeração.

    NOTA: A funcionalidade da interface de enumeração é duplicada pela interface Iterator. Além disso, o Iterator adiciona uma operação de remoção opcional e possui nomes de methods mais curtos. Novas implementações devem considerar o uso do Iterador em preferência a Enumeração.

    No Java 5, foi introduzida a interface ConcurrentMap : ConcurrentHashMap – uma implementação ConcurrentMap altamente concorrente e de alto desempenho apoiada por uma tabela de hash. Essa implementação nunca bloqueia ao executar recuperações e permite que o cliente selecione o nível de simultaneidade para atualizações. Ele tem a intenção de replace o Hashtable : além de implementar o ConcurrentMap , ele suporta todos os methods “herdados” peculiares ao Hashtable .

    • Cada valor de HashMapEntry é volátil , garantindo consistência de grão fino para modificações HashMapEntry e leituras subseqüentes; cada leitura reflete a atualização concluída mais recentemente

    • Iteradores e Enumerações são Fail Safe – refletindo o estado em algum momento desde a criação do iterador / enumeração; isso permite leituras e modificações simultâneas ao custo de consistência reduzida. Eles não lançam ConcurrentModificationException. No entanto, os iteradores são projetados para serem usados ​​por apenas um thread por vez.

    • Como o Hashtable mas ao contrário do HashMap , essa class não permite que o null seja usado como chave ou valor.

     public static void main(String[] args) { //HashMap hash = new HashMap(); Hashtable hash = new Hashtable(); //ConcurrentHashMap 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 e = hash.keys(); e.hasMoreElements(); ) { sleepThread(1); System.out.println("T2 : "+ e.nextElement()); } // HashMap traverse using Iterator, Enumeration is Fail-Fast. /* for (Iterator< Entry > it = hash.entrySet().iterator(); it.hasNext(); ) { sleepThread(1); System.out.println("T2 : "+ it.next()); // ConcurrentModificationException at java.util.Hashtable$Enumerator.next } */ /* Set< Entry > entrySet = hash.entrySet(); Iterator< Entry > it = entrySet.iterator(); Enumeration> entryEnumeration = Collections.enumeration( entrySet ); while( entryEnumeration.hasMoreElements() ) { sleepThread(1); Entry 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 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(); } } 

    « Chaves nulas e valores nulos

    HashMap permite o máximo de uma chave nula e qualquer número de valores nulos. Onde, como o Hashtable não permite nem uma única chave nula e valor nulo, se a chave ou valor nulo é, então, ele lança NullPointerException. Exemplo

    « Sincronizado, Segmento Fixo

    Hashtable é sincronizada internamente. Portanto, é muito seguro usar o Hashtable em aplicativos multi-threaded. Onde como o HashMap não está internamente sincronizado. Portanto, não é seguro usar o HashMap em aplicativos multiencadeados sem synchronization externa. Você pode sincronizar externamente o HashMap usando o método Collections.synchronizedMap() .

    « Performance

    Como o Hashtable é sincronizado internamente, isso torna o Hashtable um pouco mais lento que o HashMap .


    @Vejo

    • Uma tree vermelho-preto é um tipo de tree de pesquisa binária de auto-equilíbrio
    • Melhoria de desempenho para o HashMap no Java 8

    Além das diferenças já mencionadas, deve-se notar que, desde o Java 8, o HashMap substitui dinamicamente os Nós (linked list) usados ​​em cada bucket com TreeNodes (tree vermelha-preta), de modo que, mesmo havendo colisões hash altas, o pior caso quando procurar é

    O (log (n)) para HashMap Vs O (n) na Hashtable .

    * O aprimoramento mencionado acima não foi aplicado ao Hashtable ainda, mas apenas para HashMap , LinkedHashMap e ConcurrentHashMap .

    FYI, atualmente,

    • TREEIFY_THRESHOLD = 8 : se um intervalo contiver mais de 8 nós, a linked list será transformada em uma tree balanceada.
    • UNTREEIFY_THRESHOLD = 6 : quando um bucket se torna muito pequeno (devido a remoção ou redimensionamento), a tree é convertida de volta para a linked list.

    1. Hashmap e HashTable armazenam chave e valor.

    2. Hashmap pode armazenar uma chave como null . Hashtable não pode armazenar null .

    3. O HashMap não está sincronizado, mas a Hashtable está sincronizada.

    4. HashMap pode ser sincronizado com Collection.SyncronizedMap(map)

     Map hashmap = new HashMap(); Map map = Collections.SyncronizedMap(hashmap); 

    Existem 5 diferenciações básicas com HashTable e HashMaps.

    1. O Maps permite que você repita e recupere chaves, valores e ambos os pares de valores-chave, onde o HashTable não tem toda essa capacidade.
    2. Na Hashtable há uma function contains (), que é muito confusa de usar. Porque o significado de contém é ligeiramente divergente. Quer isso signifique contém chave ou contém valor? difícil de entender. A mesma coisa no Maps, temos as funções ContainsKey () e ContainsValue (), que são muito fáceis de entender.
    3. No hashmap você pode remover o elemento enquanto iterar, com segurança. onde, como não é possível em hashtables.
    4. HashTables são sincronizadas por padrão, portanto, podem ser usadas com vários threads facilmente. Onde os HashMaps não são sincronizados por padrão, podem ser usados ​​apenas com um único encadeamento. Mas você ainda pode converter o HashMap para sincronizar usando a function synchronizedMap (Map m) da class util do Collections.
    5. HashTable não permite chaves nulas ou valores nulos. Onde como HashMap permite uma chave nula e vários valores nulos.

    Minha pequena contribuição:

    1. A primeira diferença e a mais significativa entre o Hashtable e o HashMap é que o HashMap não é thread-safe, enquanto o Hashtable é uma coleção segura para thread.

    2. A segunda diferença importante entre o Hashtable e o HashMap é o desempenho, pois o HashMap não está sincronizado e tem um desempenho melhor que o da Hashtable .

    3. A terceira diferença no Hashtable vs HashMap é que Hashtable é uma class obsoleta e você deve usar o ConcurrentHashMap no lugar do Hashtable em Java.

    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.

    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.

    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

    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.

    Exemplo :

     import java.util.Map; import java.util.Hashtable; public class TestClass { public static void main(String args[ ]) { Map states= new Hashtable(); 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 .

    Exemplo:

     import java.util.HashMap; import java.util.Map; public class TestClass { public static void main(String args[ ]) { Map states = new HashMap(); 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)); } } 

    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.

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

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

    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