Diferenças entre HashMap e Hashtable?

https://stackoverflow.com/questions/40471

09-06-2019
|

Pergunta

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

O que é mais eficiente para os não-threaded aplicações?

Solução

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

Hashtable é sincronizado, enquanto HashMap não é.Isso faz HashMap melhor para non-threaded aplicações, como não sincronizadas normalmente, os Objetos de executar melhor do que sincronizados queridos.
Hashtable não permitir null chaves ou valores. HashMap permite que um null chave e qualquer número de null valores.
Um dos HashMap do subclasses é LinkedHashMap, então, no evento que você deseja previsível ordem de iteração (que é a ordem de inserção por padrão), você pode facilmente trocar o HashMap para um LinkedHashMap.Isso não seria tão fácil se você estivesse usando Hashtable.

Desde a sincronização não é um problema para você, eu recomendo HashMap.Se a sincronização torna-se um problema, você também pode olhar para ConcurrentHashMap.

Outras dicas

Note que um monte de respostas estado que Hashtable é sincronizado. Na prática, esta compra você muito pouco. A sincronização é o acessor / mutator métodos deixar duas threads adicionar ou remover do mapa simultaneamente, mas no mundo real, muitas vezes você vai precisar de mais de sincronização.

Um fato muito comum, a linguagem é "verifique, em seguida, colocar" — i.é.procure uma entrada no Map, e adicioná-lo se ele já não existir.Este não é de forma alguma uma operação atômica se você usar Hashtable ou HashMap.

Um equivalentemente sincronizado HashMap pode ser obtido por:

Collections.synchronizedMap(myMap);

Mas para implementar corretamente essa lógica de que você precisa adicionais de sincronização do formulário:

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

Mesmo iterando um Hashtable's entradas (ou um HashMap obtido por Collections.synchronizedMap) não é thread-safe, a menos que você também guarda o Map de ser modificado através de uma sincronização adicional.

Implementações do ConcurrentMap interface (por exemplo, ConcurrentHashMap) resolver algumas dessas incluindo thread-safe check-então-lei semântica tais como:

ConcurrentMap.putIfAbsent(key, value);

Hashtable é considerado de código legado.Não há nada sobre Hashtable que não pode ser feito usando HashMap ou derivações de HashMap, então, para o novo código, não vejo qualquer justificação para voltar para Hashtable.

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

A classe HashMap é mais ou menos equivalente a Hashtable, exceto que ele não é sincronizado e permite valores nulos.(HashMap permite valores nulos como chave e valor enquanto Hashtable não permite valores nulos).
HashMap não garante que o fim do mapa, irá permanecer constante ao longo do tempo.
HashMap não é sincronizado considerando que Hashtable é sincronizado.
Iterador no HashMap é seguro, enquanto o enumerador para o Hashtable não é e jogar ConcurrentModificationException se qualquer outro Thread modifica o mapa estruturalmente pela adição ou remoção de qualquer elemento, exceto Iterador do próprio remove() método.Mas isso não é uma garantia de comportamento e será feito pela JVM no melhor esforço.

Observação em Alguns Termos Importantes

Sincronizado significa que apenas um thread pode modificar uma tabela de hash em um ponto do tempo.Basicamente, isso significa que qualquer thread antes de executar uma atualização em uma tabela de hash terá que adquirir um bloqueio no objeto, enquanto outros vão esperar para bloquear a ser lançado.
Fail-safe é relevante para o contexto de iteradores.Se um iterador foi criado em um objeto de coleção e de algum outro thread tenta modificar o objeto de coleção "estruturalmente", uma modificação concorrente exceção será lançada.É possível que outras threads que invocar o "set" método desde que não modifique a coleção "estruturalmente".No entanto, se, antes de chamar o "set", a coleção foi modificado estruturalmente, "IllegalArgumentException" vai ser lançada.
Estruturalmente modificação significa excluir ou inserir elemento que poderia efetivamente alterar a estrutura do mapa.

HashMap podem ser sincronizados

Map m = Collections.synchronizeMap(hashMap);

Mapa fornece uma Coleção de pontos de vista, em vez disso, o apoio direto para a iteração através da Enumeração de objetos.Coleção pontos de vista de melhorar muito o a expressividade da interface, como discutido mais adiante nesta seção.Mapa permite iterar sobre chaves, valores, ou pares de chave-valor;Hashtable não fornecer a terceira opção.Mapa fornece uma maneira segura para remover entradas no meio da iteração;Hashtable não.Finalmente, Mapa corrige uma deficiência menor na Hashtable interface.Hashtable tem um método chamado contém, que retorna true se o Hashtable contém um determinado valor.Dado o seu nome, você esperaria que este método para retornar true se o Hashtable contida uma determinada chave, porque a chave é o principal mecanismo de acesso para um Hashtable.O Mapa interface elimina essa fonte de confusão por mudar o nome do método containsValue.Além disso, este procedimento melhora a interface de consistência containsValue paralelos containsKey.

A Interface De Mapa

HashMap:Uma implementação do Map interface que utiliza os códigos de hash para o índice de uma matriz.Hashtable:Oi, 1998 chamado.Eles querem suas coleções API de volta.

Seriamente embora, é melhor ficar longe de Hashtable completamente.Para single-threaded de apps, você não precisa a sobrecarga extra de sincronização.Para muito em simultâneo apps, o paranóico sincronização pode levar a starvation, deadlocks, ou desnecessária a coleta de lixo pausa.Como Tim Howland apontou, você pode usar ConcurrentHashMap em vez disso.

Tenha em mente que HashTable foi legado classe, antes do Java Collections Framework (IOP) foi introduzido e mais tarde foi adaptada para implementar o Map interface.Então foi Vector e Stack.

Portanto, sempre ficar longe deles no novo código, pois existe sempre a melhor alternativa para o IOP como os outros tinham apontado.

Aqui é o Java collection cheat sheet que você vai achar útil.Observe o bloco cinza contém o legado da classe HashTable,vetores e Pilha.

enter image description here

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

Observe também que Hashtable estende-se a Dictionary de classe, que, como o Javadocs estado, está obsoleto e foi substituído pelo Map interface.

Há muitas boas respostas já publicadas.Estou acrescentando alguns novos pontos e resumi-lo.

HashMap e Hashtable ambos são usados para armazenar dados de chave e valor de formulário.Ambos estão usando hash técnica para armazenamento de chaves únicas.Mas existem muitas diferenças entre HashMap e Hashtable aulas que são dadas abaixo.

HashMap

HashMap não é sincronizado.Não é thread safe e não pode ser compartilhada entre vários threads sem a devida sincronização de código.
HashMap permite que um nulo chave e vários valores nulos.
HashMap é uma classe nova, introduzida no JDK 1.2.
HashMap é rápido.
Nós podemos fazer a HashMap como sincronizados chamando este código
Map m = Collections.synchronizedMap(HashMap);
HashMap é atravessada pelo Iterador.
Iterador em HashMap é fail-fast.
HashMap herda AbstractMap classe.

Hashtable

Hashtable é sincronizado.É thread-safe e pode ser compartilhada com muitos fios.
Hashtable não permitir que qualquer nulo chave ou valor.
Hashtable é um legado de classe.
Hashtable é lento.
Hashtable internamente é sincronizadas e não podem ser sincronizados.
Hashtable é atravessada pelo Enumerador e Iterador.
No enumerador Hashtable não é fail-fast.
Hashtable herda a classe de Dicionário.

Ler mais Qual é a diferença entre HashMap e Hashtable em Java?

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

Java Matriz De Coleta De

Hashtable é semelhante ao HashMap e tem uma interface semelhante.É recomendável que você use HashMap, a menos que você precisa de suporte para aplicativos herdados ou você precisar de sincronização, como o Hashtables métodos são sincronizados.Então, no seu caso, como você não são multi-threading, HashMaps são a sua melhor aposta.

Outra diferença importante entre hashtable e hashmap é que Iterador no HashMap é falhar-rápido, enquanto o enumerador para o Hashtable não é e jogar ConcurrentModificationException se qualquer outro Thread modifica o mapa estruturalmente pela adição ou remoção de qualquer elemento, exceto Iterador do próprio remove() método.Mas isso não é uma garantia de comportamento 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 importantes aspectos já mencionados aqui, Coleções API (por exemplo,Interface de mapa) está sendo modificado o tempo todo conformar-se com os "melhores e mais recentes adições à especificação Java.

Compare, por exemplo, o Java 5 Mapa de iteração:

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

contra o velho Hashtable abordagem:

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

Em Java 1.8 também nos são prometidos para ser capaz de construir e de acesso HashMaps como no bom e velho linguagens de script:

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

Atualização: Não, eles não vão de terra em 1.8...:(

São o Projeto, a Moeda de coleção de acessórios vai ser em JDK8?

HashTable é sincronizado, se você estiver usando uma única thread que você pode usar HashMap, que é uma dessincronizado versão.Não sincronizadas objetos são muitas vezes um pouco mais alto desempenho.Pela maneira como se vários threads de acesso a um HashMap simultaneamente, e pelo menos um dos segmentos modifica o mapa estruturalmente, ele deve ser sincronizado externamente.Youn pode quebrar um dessincronizado mapa sincronizada de um usando :
```
Map m = Collections.synchronizedMap(new HashMap(...));
```
HashTable pode conter apenas do não-objeto nulo como uma chave ou um valor.HashMap pode conter uma chave nulo e valores nulos.
Os iteradores retornado pelo Mapa estão a falhar-rápido, se o mapa é estruturalmente modificado a qualquer momento após o iterador é criado, em qualquer forma, exceto por meio de iterador do próprio método de remover, o iterador irá lançar um ConcurrentModificationException.Assim, em face da modificação concorrente, o iterador de falha rápida e limpa, em vez de arriscar arbitrário, um comportamento não determinístico em um tempo indeterminado no futuro. Considerando que a as Enumerações devolvidos por Hashtable chaves e elementos métodos não são fail-fast.
HashMap e HashTable são membro do Java Collections Framework (desde que a plataforma Java 2 v1.2, HashTable foi adaptado para implementar a interface de Mapa).
HashTable é considerado de código legado, a documentação aconselhamos o uso de ConcurrentHashMap em lugar de Hashtable se uma thread-safe altamente simultâneas implementação é desejado.
HashMap não garante a ordem na qual os elementos são retornados.Para HashTable que eu acho que é o mesmo, mas eu não sou inteiramente certo, eu não encontrar recursos que claramente isso.

HashMap e Hashtable tem significativa de algoritmos diferenças.Ninguém mencionou isso antes, então é por isso que eu estou trazendo-o para cima. HashMap a construção de uma tabela de hash com potência de dois tamanho, aumentar dinamicamente tal que você tem, no máximo, cerca de oito elementos (colisões) em qualquer balde e vai agitar os elementos muito bem geral dos tipos de elementos.No entanto, o Hashtable implementação fornece um melhor e maior controle sobre o hash se você sabe o que está fazendo, nomeadamente, você pode corrigir a tabela de tamanho ego próximo número primo para os valores do domínio de tamanho e isso irá resultar em um melhor desempenho do que HashMap i.e.menos colisões para alguns casos.

Separado das óbvias diferenças amplamente discutido na questão, eu vejo o Hashtable como um "manual de unidade" de carro onde você terá um maior controle sobre a criação de algoritmos hash e o HashMap como a "unidade automático" de contrapartida que geralmente funcionam bem.

Hashtable é sincronizado, considerando que HashMap não.Que faz Hashtable mais lento do que Hashmap.

Para non-threaded apps, use HashMap uma vez que eles são de outra forma o mesmo em termos de funcionalidade.

Com base na informação aqui, Eu recomendo ir com HashMap.Acho que a maior vantagem é que o Java vai impedir você de modificá-lo enquanto você está iterando sobre ele, a menos que você fazê-lo através do iterador.

Um Collection — às vezes chamado de um recipiente é simplesmente um objeto que grupos de vários elementos em uma única unidade. Collections são usados para armazenar, recuperar, manipular e comunicar dados agregados.Um framework de coleções ^W é uma arquitetura unificada para a representação e manipulação de coleções.

O HashMap ^JDK1.2 e Hashtable ^JDK1.0, ambos são usados para representar um grupo de objetos que são representados em <Key, Value> par.Cada <Key, Value> par é chamado Entry objecto.O conjunto de Entradas é referido pelo objeto de HashMap e Hashtable.Chaves em uma coleção deve ser único ou distinto.[como eles são usados para recuperar o mapeamento de um valor de uma chave em particular.valores em uma coleção pode ser duplicado.]

« Superclasse, Legado e a Estrutura de Coleta membro

Hashtable é um legado de classe introduzida em JDK1.0, que é uma subclasse da classe de Dicionário.A partir de JDK1.2 Hashtable é re-projetado para implementar o Interface de mapa para se tornar um membro de estrutura de coleta.HashMap é um membro do Java Collection Framework, desde o início da sua introdução no JDK1.2.HashMap é a subclasse da AbstractMap classe.

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 { ... }

« Capacidade inicial e fator de Carga

A capacidade é o número de baldes na tabela de hash, e a capacidade inicial é simplesmente a capacidade no momento em que a tabela de hash é criada.Note que a tabela de hash é aberto:no caso de um "hashcollision"um único balde de lojas de várias entradas, o que deve ser pesquisado de forma sequencial.O fator de carga é uma medida de quão completa a tabela de hash é permitido obter antes de sua capacidade é automaticamente aumentado.

HashMap constrói um vazio tabela de hash com o padrão de capacidade inicial (16) e o padrão do fator de carga (0.75).Onde, como Hashtable construções vazio hashtable com um padrão capacidade inicial (11) e fator de carga/taxa de preenchimento (0.75).

« Mudanças estruturais no caso de colisão de hash

HashMap, Hashtable em caso de colisões de hash, eles armazenam o mapa de entradas nas listas ligadas. A partir de Java8 para HashMap se hash balde cresce além de um certo limite, que balde vai mudar a partir de linked list of entries to a balanced tree.que melhorar desempenho pior de S(n) para O(n log n).Enquanto convertendo a lista em árvore binária, hashcode é usado como uma ramificação variável.Se existem dois tipos diferentes de hashcodes no mesmo balde, é considerada a maior e vai para a direita da árvore e outra para a esquerda.Mas quando o hashcodes são iguais, HashMap pressupõe que as teclas são comparáveis, e compara a chave para determinar a direção para que a ordem possa ser mantida.É uma boa prática para fazer as chaves do HashMap comparável.Sobre como adicionar entradas de se atinge o tamanho do balde TREEIFY_THRESHOLD = 8 converter lista ligada de entradas para uma árvore balanceada, sobre a remoção de entradas de menos de TREEIFY_THRESHOLD e no mais UNTREEIFY_THRESHOLD = 6 vai reconverter árvore balanceada ligados lista de entradas. ^{Java 8 SRC, stackpost}

« Coleção-ver iteração, Falhar Rápido e Seguro

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

Iterator é uma falha de rápida na natureza.eu.e ele lança ConcurrentModificationException se uma coleção é modificado durante a iteração mais do que isso, do próprio remove() método.Onde, como Enumeration falhas na natureza.Não jogue quaisquer exceções se uma coleção é modificado durante a iteração.

De acordo com Java API do google Docs, o Iterador é sempre a preferência sobre o Enumeração.

_{NOTA: A funcionalidade de interface de Enumeração é duplicado pelo Iterador interface.Além disso, o Iterador adiciona um opcional de operação de remover, e tem mais curto nomes de método.Novas implementações devem considerar o uso de Iterador de preferência a Enumeração.}

No Java 5 introduzido ConcurrentMap Interface: ConcurrentHashMap - altamente concorrente, de alto desempenho ConcurrentMap implementação apoiado por uma tabela de hash.Esta implementação nunca blocos quando a efectuar recuperações e permite que o cliente escolha o nível de concorrência para atualizações.Destina-se como uma lista drop-em substituição por Hashtable:além de implementar ConcurrentMap, ele suporta todos os "legado" métodos peculiares para Hashtable.

Cada HashMapEntryvalor s é volátil assegurando, assim, de grão fino a consistência para sustentou modificações e leituras subseqüentes;cada leitura reflete mais recentemente concluída atualização
Os iteradores e Enumerações são falhas de Segurança - que reflete o estado em algum momento, desde a criação do iterador/contagem;isso permite a simultânea leituras e modificações no custo de redução de consistência.Eles não jogue ConcurrentModificationException.No entanto, os iteradores são projetados para ser usado por apenas uma thread de cada vez.
Como Hashtable mas ao contrário de HashMap, esta classe não permite valor nulo para ser usado como uma chave ou valor.

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 Chaves E Valores Nulos

HashMap permite o máximo de uma chave nulo e qualquer número de valores nulos.Onde, como Hashtable não permitir que até mesmo uma única chave nulo e o valor nulo, se a chave ou o valor null é, em seguida, lança NullPointerException. ^Exemplo

« Sincronizados, Thread-Safe

Hashtable internamente é sincronizado.Portanto, é muito seguro de usar Hashtable multi-threaded aplicações.Onde, como HashMap não é internamente sincronizados.Portanto, não é seguro usar HashMap multi-threaded aplicações sem a sincronização externa.Você pode sincronizar externamente HashMap usando Collections.synchronizedMap() o método.

« Desempenho

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

@Veja

Para threaded apps, muitas vezes você pode começar afastado com ConcurrentHashMap - depende de seus requisitos de desempenho.

1.Hashmap e HashTable tanto o armazenamento de chave e valor.

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

3.HashMap não é sincronizado, mas Hashtable é sincronizado.

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

Map hashmap = new HashMap();

Map map = Collections.SyncronizedMap(hashmap);

Além das diferenças já mencionadas, deve ser notado que, desde o Java 8, HashMap substitui dinamicamente os Nós (lista ligada) utilizado em cada balde com TreeNodes (red-black tree), de modo que mesmo se um número elevado de colisões de hash existir, o pior caso quando a pesquisa é

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

*A referida melhoria não tenha sido aplicada a Hashtable mas, apenas para HashMap, LinkedHashMap, e ConcurrentHashMap.

FYI, atualmente,

TREEIFY_THRESHOLD = 8 :se um balde contém mais de 8 nós, a lista ligada, é transformada em uma árvore balanceada.
UNTREEIFY_THRESHOLD = 6 :quando um balde torna-se muito pequeno (por remoção ou redimensionamento) a árvore é convertido de volta para lista ligada.

Há 5 basic diferenciações com HashTable e HashMaps.

Mapas permite iterar e recuperar chaves, valores, e ambos os pares de chave-valor, Onde o HashTable não tem esta capacidade.
Na Hashtable existe uma função contains(), que é muito confuso para usar.Porque o significado da contém é ligeiramente divergentes.Se isso significa que contém a chave ou com o valor?difícil de entender.Mesma coisa no google Maps temos ContainsKey() e ContainsValue() funções, que são muito fáceis de entender.
No hashmap você pode remover o elemento enquanto iteração, com segurança.onde, uma vez que não é possível em tabelas de hash.
Tabelas de hash são, por padrão, sincronizado, de modo que ele pode ser usado com vários threads facilmente.Onde, como HashMaps não são sincronizadas por padrão, portanto, pode ser usado com apenas uma única thread.Mas você ainda pode converter HashMap para sincronizados usando Coleções util classe synchronizedMap(Mapa m) função.
HashTable não permitir null chaves ou valores nulos.Onde, como HashMap permite que uma chave nulo, e vários valores nulos.

Minha pequena contribuição :

Primeiro e mais significativo diferentes entre Hashtable e HashMap é que, HashMap não é thread-safe, enquanto Hashtable é uma thread-safe coleção.

Segunda diferença importante entre Hashtable e HashMap é o seu desempenho, desde HashMap não é sincronizado-lo a executar melhor do que Hashtable.

Terceira diferença em Hashtable vs HashMap é que Hashtable é obsoletas de classe e você deve estar usando ConcurrentHashMap em lugar de Hashtable em Java.

HashTable é um legado de classes do jdk que não deve ser mais usado.Substitua os seus usos com ConcurrentHashMap.Se você não precisar de segurança do thread, use HashMap o que não é threadsafe mas mais rapidamente e usa menos memória.

1)Hashtable é sincronizado considerando que hashmap é não.2)Outra diferença é que o iterador no HashMap é seguro, enquanto o enumerador para o Hashtable não.Se você alterar o mapa, enquanto iteração, você vai saber.

3)HashMap permite valores nulos em que, ao Hashtable não.

HashMap e HashTable

Alguns pontos importantes sobre HashMap e HashTable.por favor leia detalhes abaixo.

1) Hashmap e Hashtable implementar o java.util.Interface de mapa 2) Ambos os Hashmap e Hashtable é o hash com base coleção.e trabalhando na criação de algoritmos hash.então, esses são similaridade dos HashMap e HashTable.

Qual é a diferença entre HashMap e HashTable?

1) a Primeira diferença é HashMap não é thread-safe, Enquanto HashTable é ThreadSafe
2) HashMap é o desempenho sábios melhor porque ele não é thread-safe.enquanto Hashtable desempenho sábio não é melhor porque ele é thread-safe.por isso, vários thread não pode acessar Hashtable ao mesmo tempo.

HashMap:É uma classe dentro do java.util pacote e é usado para armazenar o elemento chave e valor de formato.

Hashtable:É um legado de classe que está a ser reconhecido dentro da estrutura de coleta.

Hashtable:

Hashtable é uma estrutura de dados que mantém os valores do par chave-valor.Ele não permite nulos para as chaves e os valores.Você vai ter um NullPointerException se você adicionar valor nulo.Ele é sincronizado.Então, ele vem com seu custo.Apenas um thread pode acessar HashTable em um determinado momento.

Exemplo :

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 é como Hashtable mas ele também aceita o par de valor-chave.Ele permite nulo para as chaves e os valores.Seu melhor desempenho é melhor do que HashTable, porque ele é unsynchronized.

Exemplo:

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

    }
}

HashMaps dá a você a liberdade de sincronização e a depuração é muito mais fácil

HashMap é emulada e, portanto, utilizável em GWT client code considerando que a Hashtable não é.

Sincronização de Thread-Safe :

Hash do Mapa não está sincronizado por isso, não thred seguro e ele não pode ser compartilhado entre vários threads sem a devida sincronizado bloco considerando que, Hashtable é sincronizado e, portanto, é thread-safe.

Null chaves e valores nulos :

HashMap permite que uma chave nulo e qualquer número de valores nulos.Hashtable não permitir null chaves ou valores.

Iteração os valores:

Iterador no HashMap é um fail-fast iterador enquanto o enumerador para o Hashtable não é e jogar ConcurrentModificationException se qualquer outro Thread modifica o mapa estruturalmente pela adição ou remoção de qualquer elemento, exceto Iterador do próprio remove() método.

Superclasse e Legado :

HashMap é subclasse de AbstractMap considerando que a classe Hashtable é subclasse da classe de Dicionário.

Desempenho :

Como HashMap não está sincronizado é mais rápido se comparado ao Hashtable.

Consulte http://modernpathshala.com/Article/1020/difference-between-hashmap-and-hashtable-in-java para exemplos e perguntas da entrevista e do questionário relacionadas a Java collection

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow