Diferencia entre tabla hash y mapa sincronizado en Java

La clase Hashtable implementa una tabla hash, que asigna claves a valores. Cualquier objeto no nulo se puede utilizar como clave o como valor. Para almacenar y recuperar con éxito objetos de una tabla Hash, los objetos utilizados como claves deben implementar el método hashCode y también el método equals.  

Características de la tabla hash:

• Es algo así como HashMap pero está sincronizado.
• Hashtable almacena el par clave/valor en la tabla hash.
• En Hashtable especificamos un objeto que se usa como clave y el valor que queremos asociar con esa clave. A continuación, se aplica un hash a la clave y el código hash resultante se utiliza como índice en el que se almacena el valor dentro de la tabla.
• La capacidad predeterminada inicial de la clase Hashtable es 11, mientras que el factor de carga es 0,75.
• HashMap no proporciona ninguna enumeración, mientras que Hashtable no proporciona una enumeración rápida.

Ejemplo:

// Java program to demonstrate the
// usage of HashTable
  
import java.util.*;
class Hashtable1 {
    public static void main(String args[])
    {
        // Creating a HashTable
        Hashtable<Integer, String> mytable = new Hashtable<Integer, String>();
  
        // Adding elements to HashTable
        mytable.put(1, "James Bond");
        mytable.put(2, "Donald Trumph");
        mytable.put(3, "Joe Biden");
        mytable.put(4, "Mona Lisa");
  
        // Iterating through HashTable
        for (Map.Entry m : mytable.entrySet()) 
        {
            System.out.println(m.getKey() + " "
                               + m.getValue());
        }
    }
}

4 Mona Lisa
3 Joe Biden
2 Donald Trumph
1 James Bond

SynchronizedHashMap

• Sincronización a nivel de Objeto.
• Cada operación de lectura/escritura necesita adquirir un bloqueo.
• Bloquear toda la colección es una sobrecarga de rendimiento.
• Básicamente, esto da acceso a un solo hilo a todo el mapa y bloquea todos los demás hilos.
• Puede causar contención.
• SynchronizedHashMap devuelve Iterator, que falla rápidamente en la modificación simultánea.

Ejemplo:

// Java program to demonstrate the
// usage of Synchronized HashMap
  
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapSyncExample {
    public static void main(String args[])
    {
        // Creating HashMap
        HashMap<Integer, String> hmap = new HashMap<Integer, String>();
        
        // Adding elements in HashMap
        hmap.put(2, "Anil");
        hmap.put(44, "Ajit");
        hmap.put(1, "Brad");
        hmap.put(4, "Sachin");
        hmap.put(88, "XYZ");
  
        Map map = Collections.synchronizedMap(hmap);
        Set set = map.entrySet();
        
        synchronized (map)
        {
            Iterator i = set.iterator();
            
            // Display elements
            while (i.hasNext())
            {
                Map.Entry me = (Map.Entry)i.next();
                System.out.print(me.getKey() + ": ");
                System.out.println(me.getValue());
            }
        }
    }
}

1: Brad
2: Anil
4: Sachin
88: XYZ
44: Ajit

Hashtable vs SynchronizedHashMap