A classe Hashtable implementa uma tabela hash, que mapeia chaves para valores. Qualquer objeto não nulo pode ser usado como chave ou valor. Para armazenar e recuperar objetos de uma tabela de hash com êxito, os objetos usados ​​como chaves devem implementar o método hashCode e o método equals.  

Recursos do Hashtable

• É semelhante ao HashMap, mas é sincronizado.
• A tabela de hash armazena o par chave / valor na tabela de hash.
• Em Hashtable, especificamos um objeto que é usado como uma chave e o valor que queremos associar a essa chave. A chave é então hash e o código hash resultante é usado como o índice no qual o valor é armazenado na tabela.
• A capacidade padrão inicial da classe Hashtable é 11, enquanto loadFactor é 0,75.
• HashMap não fornece qualquer Enumeração, enquanto Hashtable não fornece Enumeração rápida para falhas.

Declaração:

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

Parâmetros de tipo:

• K - o tipo de chaves mantidas por este mapa
• V - o tipo de valores mapeados

A hierarquia da tabela de hash

Hashtable implementa interfaces Serializable , Cloneable , Map <K, V> e estende Dictionary <K, V> . As subclasses diretas são Propriedades , UIDefaults .
 

Construtores:

Para criar um Hashtable, precisamos importá-lo de java.util.Hashtable . Existem várias maneiras de criar um Hashtable.

1. Hashtable(): Isso cria uma hashtable vazia com o fator de carga padrão de 0,75 e uma capacidade inicial de 11. 

Hashtable <K, V> ht = nova Hashtable <K, V>();

// Java program to demonstrate
// adding elements to Hashtable
  
import java.io.*;
import java.util.*;
  
class AddElementsToHashtable {
    public static void main(String args[])
    {
        // No need to mention the
        // Generic type twice
        Hashtable<Integer, String> ht1 = new Hashtable<>();
  
        // Initialization of a Hashtable
        // using Generics
        Hashtable<Integer, String> ht2
            = new Hashtable<Integer, String>();
  
        // Inserting the Elements
        // using put() method
        ht1.put(1, "one");
        ht1.put(2, "two");
        ht1.put(3, "three");
  
        ht2.put(4, "four");
        ht2.put(5, "five");
        ht2.put(6, "six");
  
        // Print mappings to the console
        System.out.println("Mappings of ht1 : " + ht1);
        System.out.println("Mappings of ht2 : " + ht2);
    }
}

Mapeamentos de ht1: {3 = três, 2 = dois, 1 = um}
Mapeamentos de ht2: {6 = seis, 5 = cinco, 4 = quatro}

2. Hashtable (int initialCapacity): Isso cria uma tabela hash que tem um tamanho inicial especificado por initialCapacity e o fator de carga padrão é 0,75.

Hashtable <K, V> ht = nova Hashtable <K, V> (int initialCapacity);

// Java program to demonstrate
// adding elements to Hashtable
  
import java.io.*;
import java.util.*;
  
class AddElementsToHashtable {
    public static void main(String args[])
    {
        // No need to mention the
        // Generic type twice
        Hashtable<Integer, String> ht1 = new Hashtable<>(4);
  
        // Initialization of a Hashtable
        // using Generics
        Hashtable<Integer, String> ht2
            = new Hashtable<Integer, String>(2);
  
        // Inserting the Elements
        // using put() method
        ht1.put(1, "one");
        ht1.put(2, "two");
        ht1.put(3, "three");
  
        ht2.put(4, "four");
        ht2.put(5, "five");
        ht2.put(6, "six");
  
        // Print mappings to the console
        System.out.println("Mappings of ht1 : " + ht1);
        System.out.println("Mappings of ht2 : " + ht2);
    }
}

Mapeamentos de ht1: {3 = três, 2 = dois, 1 = um}
Mapeamentos de ht2: {4 = quatro, 6 = seis, 5 = cinco}

3. Hashtable (int size, float fillRatio): Esta versão cria uma tabela hash que tem um tamanho inicial especificado por tamanho e taxa de preenchimento especificada por fillRatio. taxa de preenchimento: Basicamente, ele determina o quão cheia uma tabela de hash pode ser antes de ser redimensionada para cima e seu valor ficar entre 0,0 e 1,0.

Hashtable <K, V> ht = new Hashtable <K, V> (tamanho interno, float fillRatio);

// Java program to demonstrate
// adding elements to Hashtable
  
import java.io.*;
import java.util.*;
  
class AddElementsToHashtable {
    public static void main(String args[])
    {
        // No need to mention the
        // Generic type twice
        Hashtable<Integer, String> ht1
            = new Hashtable<>(4, 0.75f);
  
        // Initialization of a Hashtable
        // using Generics
        Hashtable<Integer, String> ht2
            = new Hashtable<Integer, String>(3, 0.5f);
  
        // Inserting the Elements
        // using put() method
        ht1.put(1, "one");
        ht1.put(2, "two");
        ht1.put(3, "three");
  
        ht2.put(4, "four");
        ht2.put(5, "five");
        ht2.put(6, "six");
  
        // Print mappings to the console
        System.out.println("Mappings of ht1 : " + ht1);
        System.out.println("Mappings of ht2 : " + ht2);
    }
}

Mapeamentos de ht1: {3 = três, 2 = dois, 1 = um}
Mapeamentos de ht2: {6 = seis, 5 = cinco, 4 = quatro}

4. Tabela de hash (Map <? Extends K ,? extends V> m): Isso cria uma tabela de hash que é inicializada com os elementos em m.

Hashtable <K, V> ht = nova Hashtable <K, V> (Mapa m);

// Java program to demonstrate
// adding elements to Hashtable
  
import java.io.*;
import java.util.*;
  
class AddElementsToHashtable {
    public static void main(String args[])
    {
        // No need to mention the
        // Generic type twice
        Map<Integer, String> hm = new HashMap<>();
  
        // Inserting the Elements
        // using put() method
        hm.put(1, "one");
        hm.put(2, "two");
        hm.put(3, "three");
  
        // Initialization of a Hashtable
        // using Generics
        Hashtable<Integer, String> ht2
            = new Hashtable<Integer, String>(hm);
  
        // Print mappings to the console
  
        System.out.println("Mappings of ht2 : " + ht2);
    }
}

Mapeamentos de ht2: {3 = três, 2 = dois, 1 = um}

Exemplo:

// Java program to illustrate
// Java.util.Hashtable
  
import java.util.*;
  
public class GFG {
    public static void main(String[] args)
    {
        // Create an empty Hashtable
        Hashtable<String, Integer> ht = new Hashtable<>();
  
        // Add elements to the hashtable
        ht.put("vishal", 10);
        ht.put("sachin", 30);
        ht.put("vaibhav", 20);
  
        // Print size and content
        System.out.println("Size of map is:- " + ht.size());
        System.out.println(ht);
  
        // Check if a key is present and if
        // present, print value
        if (ht.containsKey("vishal")) {
            Integer a = ht.get("vishal");
            System.out.println("value for key"
                               + " \"vishal\" is:- " + a);
        }
    }
}

O tamanho do mapa é: - 3
{vaibhav = 20, vishal = 10, sachin = 30}
o valor da chave "vishal" é: - 10

Executando Várias Operações em Hashtable                  

1. Adicionando Elementos: Para adicionar um elemento à tabela de hash, podemos usar o método put() . No entanto, o pedido de inserção não é retido na tabela de hash. Internamente, para cada elemento, um hash separado é gerado e os elementos são indexados com base nesse hash para torná-lo mais eficiente.                      

// Java program to demonstrate
// adding elements to Hashtable
  
import java.io.*;
import java.util.*;
  
class AddElementsToHashtable {
    public static void main(String args[])
    {
        // No need to mention the
        // Generic type twice
        Hashtable<Integer, String> ht1 = new Hashtable<>();
  
        // Initialization of a Hashtable
        // using Generics
        Hashtable<Integer, String> ht2
            = new Hashtable<Integer, String>();
  
        // Inserting the Elements
          // using put() method
        ht1.put(1, "Geeks");
        ht1.put(2, "For");
        ht1.put(3, "Geeks");
  
        ht2.put(1, "Geeks");
        ht2.put(2, "For");
        ht2.put(3, "Geeks");
          
          // Print mappings to the console
        System.out.println("Mappings of ht1 : " + ht1);
        System.out.println("Mappings of ht2 : " + ht2);
    }
}

Mapeamentos de ht1: {3 = Geeks, 2 = For, 1 = Geeks}
Mapeamentos de ht2: {3 = Geeks, 2 = For, 1 = Geeks}

2. Alterando Elementos: Depois de adicionar os elementos, se desejarmos alterar o elemento, isso pode ser feito adicionando novamente o elemento com o método put() . Uma vez que os elementos na tabela de hash são indexados usando as chaves, o valor da chave pode ser alterado simplesmente inserindo o valor atualizado para a chave que desejamos alterar.

// Java program to demonstrate
// updating Hashtable
  
import java.io.*;
import java.util.*;
class UpdatesOnHashtable {
    public static void main(String args[])
    {
  
        // Initialization of a Hashtable
        Hashtable<Integer, String> ht
            = new Hashtable<Integer, String>();
  
        // Inserting the Elements
          // using put method
        ht.put(1, "Geeks");
        ht.put(2, "Geeks");
        ht.put(3, "Geeks");
          
          // print initial map to the console
        System.out.println("Initial Map " + ht);
          
          // Update the value at key 2
        ht.put(2, "For");
          
          // print the updated map
        System.out.println("Updated Map " + ht);
    }
}

Mapa inicial {3 = Geeks, 2 = Geeks, 1 = Geeks}
Mapa atualizado {3 = Geeks, 2 = For, 1 = Geeks}

3. Removendo Elemento: Para remover um elemento do Mapa, podemos usar o método remove() . Este método pega o valor da chave e remove o mapeamento de uma chave deste mapa, se estiver presente no mapa.

// Java program to demonstrate
// the removing mappings from Hashtable
  
import java.io.*;
import java.util.*;
class RemovingMappingsFromHashtable {
  
    public static void main(String args[])
    {
        // Initialization of a Hashtable
        Map<Integer, String> ht
            = new Hashtable<Integer, String>();
  
        // Inserting the Elements
          // using put method
        ht.put(1, "Geeks");
        ht.put(2, "For");
        ht.put(3, "Geeks");
        ht.put(4, "For");
  
        // Initial HashMap
        System.out.println("Initial map : " + ht);
  
          // Remove the map entry with key 4
        ht.remove(4);
  
        // Final Hashtable
        System.out.println("Updated map : " + ht);
    }
}

Mapa inicial: {4 = For, 3 = Geeks, 2 = For, 1 = Geeks}
Mapa atualizado: {3 = Geeks, 2 = For, 1 = Geeks}

4. Traversal de uma Hashtable: Para iterar a tabela, podemos fazer uso de um loop for avançado . Abaixo está o exemplo de iteração de uma tabela de hash.

// Java program to illustrate
// traversal of Hashtable
  
import java.util.Hashtable;
import java.util.Map;
  
public class IteratingHashtable {
    public static void main(String[] args)
    {
          // Create an instance of Hashtable
        Hashtable<String, Integer> ht = new Hashtable<>();
  
          // Adding elements using put method
        ht.put("vishal", 10);
        ht.put("sachin", 30);
        ht.put("vaibhav", 20);
      
          // Iterating using enhanced for loop
        for (Map.Entry<String, Integer> e : ht.entrySet())
            System.out.println(e.getKey() + " "
                               + e.getValue());
    }
}

vaibhav 20
Vishal 10
sachin 30

 Trabalho Interno de Hashtable

Estrutura de dados Hashtable é uma matriz de baldes que armazena os pares de chave / valor neles. Ele usa o método hashCode() para determinar qual intervalo o par chave / valor deve mapear.
A função hash ajuda a determinar a localização de uma determinada chave na lista de depósitos. Geralmente, hashcode é um número inteiro não negativo que é igual para Objetos iguais e pode ou não ser igual para Objetos desiguais. Para determinar se dois objetos são iguais ou não, hashtable usa o método equals().

É possível que dois Objetos desiguais tenham o mesmo código hash. Isso é chamado de colisão . Para resolver as colisões, o hashtable usa uma série de listas. Os pares mapeados para um único depósito (índice de matriz) são armazenados em uma lista e a referência de lista é armazenada no índice de matriz.

Métodos de Hashtable

• K - o tipo das chaves no mapa.
• V - Tipo de valores mapeados no mapa.

Métodos declarados na interface java.util.Map

Deve ler:

• Diferenças entre HashMap e HashTable em Java

Referência: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html