¿Por qué String es una clave HashMap popular en Java?

Hay muchos casos en los que los datos se almacenan como pares clave-valor. En Java, se puede lograr mediante un «mapa», que es una colección. Por lo general, las claves no deben ser nulas y deben apuntar a un solo valor. En Map, hay varias clases disponibles y entre ellas, Hashmap es una clase que implementa la interfaz Map.

Hashmap se basa en Hashtable. Puede permitir valores nulos y claves nulas.

• Lo más importante es que la clave debe ser única y con esa clave única, podemos recuperar los valores rápidamente. 
• Primero, veamos un ejemplo de almacenamiento y visualización de datos usando Hashmap, y luego veremos por qué String es una clave de hashmap popular en Java.

Almacenemos algunos datos de personas que contengan sus números de teléfono móvil:

// HashMap is available in util package
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
// Scanner is needed to get inputs and
// it is also in util package
import java.util.Scanner;
public class StringHashMapExample {
    public static void main(String args[])
    {
        HashMap<String, Long> hashMapOfUsers
            = new HashMap<String, Long>();
        System.out.println(
            "How many person details containing phone"
            "numbers are going to get stored: ");
        Scanner scanner = new Scanner(System.in);
        int phoneNumber = scanner.nextInt();
        for (int i = 0; i < phoneNumber; i++) {
            System.out.println(
                "Enter User Name [key (String)]: ");
            String key = scanner.next();
            System.out.println(
                "Enter Phone Number [value (Long)]: ");
            long value = scanner.nextLong();
  
            // Let us store key values as
            // lower case
            hashMapOfUsers.put(key.toLowerCase(), value);
        }
        System.out.println(
            "Get the details of users . . . . . .");
        Iterator hmIterator
            = hashMapOfUsers.entrySet().iterator();
  
        // Iterating through Hashmap
        while (hmIterator.hasNext()) {
            Map.Entry hashMapElement
                = (Map.Entry)hmIterator.next();
  
            // Printing mark corresponding
            // to string entries
            System.out.println(hashMapElement.getKey()
                               + " : "
                               + hashMapElement.getValue());
        }
  
        System.out.println(
            "Enter a name to search in the hashmap(key): ");
        String reqKey = scanner.next();
  
        // To avoid case mismatch of user names,
        // it is converted to lower case
        System.out.println(
            "Phone number (value): "
            + hashMapOfUsers.get(reqKey.toLowerCase()));
    }
}

Producción:

 

¿Por qué «String» es una clave HashMap popular en Java?

1. Código hash:

• Cuando almacenamos los datos usando HashMap, se calcula un código hash de la clave dada, por ejemplo, hemos dado 2 claves en el ejemplo anterior y para ellas,  
• El código hash se calcula y su valor se coloca en la posición representada por el código hash resultante de la clave.
• De manera similar, mientras se recuperan los datos, se vuelve a calcular el código hash, de esta manera se recupera el valor en la posición representada por el código hash. Siempre comprobando la igualdad de ambos códigos hash, se recupera el valor.
• Además de String, si usamos cualquier otro tipo de datos e intentamos cambiar el valor y también la clave, el valor hash almacenado (en el tiempo de almacenamiento) y el valor hash recuperado (durante el tiempo de obtención) definitivamente variarán y, por lo tanto, no podemos recuperar el valor apt. 

2. Inmutabilidad:

• Una string es inmutable . No podemos modificar el valor de la string después de que se haya creado. Esta es la principal ventaja. es decir, el código hash sigue siendo el mismo mientras se almacena y también se recupera. Por lo tanto, siempre y también es un enfoque popular el uso de una variable de string para contener claves en un mapa hash.
• El código hash se almacena en caché y no es necesario calcularlo nuevamente (como String inmutable)
• La inmutabilidad es un gran mecanismo para obtener el mismo código hash cada vez, para un objeto clave. Por lo tanto, siempre es ideal optar por String y resuelve las fugas de memoria, la falta de disponibilidad de valores, etc.  
• El contrato de los métodos hashCode() y equals() está jugando cuando los datos se almacenan en HashMap. La string debido a la inmutabilidad proporciona el máximo soporte para esto.