1. A diferença entre hashmap e hashtable
Vamos primeiro olhar para a definição de duas classes
Hashtable de classe pública Extende o mapa de implementos de dicionário, clonável, java.io.serializable
A classe pública Hashmap estende o mapa de implementos abstrataMap, clonável, serializável
Pode -se ver que Hashtable herda do Dicionário e Hashmap herda do AbstractMap
O método de put de hashtable é o seguinte
public sincronizado v put (K -Key, V Valor) {// ########## NOTA aqui 1 // Verifique se o valor não é nulo se (value == null) {// ####### NOTA AQUI 2 LONGE } // garante que a chave ainda não esteja na hashtable. Guia de entrada [] = tabela; int hash = key.hashcode (); // ######## NOTA AQUI for (entrada e = tab [index]; e! = null; e = e.next) {if ((e.hash == hash) && e.key.equals (key)) {v antiga = e.value; E.Value = Value; retornar antigo; }} modCount ++; if (count> = limiar) {// refaz a tabela se o limite for excedido de rehash (); tab = tabela; índice = (hash & 0x7fffffff) % tab.length; } // cria a nova entrada. Entrada e = tab [index]; tab [index] = nova entrada (hash, chave, valor, e); contagem ++; retornar nulo; } Nota 1 O método é síncrono
Nota 2 O método não permite valor == nulo
Nota 3 O método chama o método HashCode da chave. Se key == NULL, uma exceção de ponteiro nulo será lançada. O método de put de hashmap é o seguinte.
public V PUT (Key K, V Valor) {// ########## NOTA aqui 1 se (key == null) // ######## NOTA aqui 2 retorna putformullKey (valor); int hash = hash (key.hashcode ()); int i = indexfor (hash, tabela.length); for (entrada e = tabela [i]; e! = null; e = e.next) {objeto k; if (e.hash == hash && ((k = e.Key) == key || key.equals (k))) {v OldValue = e.value; E.Value = Value; E.RecordAccess (isto); retornar OldValue; }} modCount ++; addentry (hash, chave, valor, i); // ######## NOTA AQUI retornar NULL; } Nota 1 O método é assíncrono
Nota 2 Método permite key == null
Nota 3 O método não faz nenhuma chamada para o valor, por isso pode ser nulo.
Reabastecer:
A hashtable possui um método contém, que pode causar facilmente mal -entendidos, por isso foi removido no hashmap.
Obviamente, ambas as classes usam os métodos ContainsKey e containsvalue.
| Hashmap | Hashtable | |
| Classe de pai | AbstractMap | Dicionário |
| É sincronizado | não | sim |
| K, pode ser nulo | sim | não |
Hashmap é uma implementação leve da hashtable (implementação não-segura de thread). Todos eles completam a interface do mapa. A principal diferença é que o hashmap permite teclas nulas. Devido ao seguinte, pode ser mais eficiente do que a hashtable.
O hashmap permite nulo como uma chave ou valor de uma entrada, enquanto a hashtable não.
O hashmap remove o hashtable contém o método e altera -o para contém valores e contains. Porque o método contém é fácil causar mal -entendidos.
Heritos de hashtable da classe de dicionário, e o hashmap é uma implementação da interface do mapa introduzida pelo Java 1.2.
A maior diferença é que o método de hashtable é sincronizado, enquanto o hashmap não é. Quando vários threads acessarem a hashtable, eles não precisam sincronizar seus próprios métodos, e o hashmap deve fornecer sincronização externa (coleções.synchronizedmap).
Os algoritmos de hash/rehash usados por hashtable e hashmap são aproximadamente os mesmos, portanto não haverá grande diferença no desempenho.
Resumir:
Os valores -chave no hashmap podem estar vazios e são assíncronos
O valor chave em hashtable não pode ser nulo e é sincronizado
A herança é diferente, mas ambos implementam a interface do mapa
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.