Interfaz de mapa en Java

¿Qué es la interfaz de mapas de Java?

La interfaz Java Map es parte del marco de Java Collection, pero no es un subtipo de la interfaz Collection. Por lo tanto, se comporta de manera diferente en comparación con, por ejemplo, Listas u otros Objetos de colección. Cada elemento de Map<Key, Value> representa un par clave-valor. Tanto la clave como el valor son algunos objetos. Todas las claves en un mapa en particular son únicas, mientras que los valores no lo son, por lo que se pueden duplicar. Puede pensar en Map en Java como una especie de diccionario o catálogo de una tienda en línea, donde puede encontrar cualquier artículo usando su índice único. La clave es un identificador único del valor en un mapa. Por ejemplo, en Map<String, Item> String es un ID de algún artículo de la tienda en línea. Según la documentación, Map tiene las siguientes subinterfaces:

encuadernaciones ;

ConcurrentMap<K,V> ;

ConcurrentNavigableMap<K,V> ;

ContextoMensajeLógico ;

MensajeContexto ;

MapaNavegable<K,V> ;

SOAPMessageContext ;

SortedMap<K,V> .

E implementa clases:

ResumenMapa
Atributos
Proveedor de autenticación
ConcurrentHashMapConcurrentHashMap
Mapa de lista de saltos simultáneos
EnumMap
mapa hash
Tabla de picadillo
IdentityHashMap
LinkedHashMap
ImpresoraEstadoRazones
Propiedades
Proveedor
Sugerencias de renderizado
Enlaces simples
Soporte de datos tabulares
ÁrbolMapa
Valores predeterminados de la interfaz de usuario
WeakHashMap

Java AbstractMap es una clase abstracta que implementa la mayor parte de la interfaz Map.
Java HashMap es una estructura de datos para almacenar pares clave-valor utilizando una tabla hash.
Java TreeMap es una estructura de datos para usar un árbol, es decir, mostrar con claves ordenadas.
WeakHashMap para usar una tabla hash con claves débiles, mostrar con valores que el recolector de basura puede eliminar si ya no se usan.
LinkedHashMap es un mapa con el orden de agregar elementos, permite la iteración en el orden de inserción.
EnumMap extiende la clase AbstractMap para usar con claves de enumeración.

IdentityHashMap usa la verificación de equivalencia referencial al comparar documentos, mapeando con claves comparadas usando la operación == en lugar del método equals()

Aquí estamos interesados en las implementaciones más populares de Map Interface: HashMap, TreeMap y LinkedHashMap. Por cierto, el orden de los elementos del mapa depende de implementaciones específicas. Digamos, TreeMap y LinkedHashMap tienen un orden predecible de los elementos, mientras que HashMap no.

Métodos de mapa

Las principales operaciones de cualquier Mapa son la inserción, eliminación y búsqueda de elementos.

Public Object put (clave de objeto, valor de objeto) inserta un elemento en el mapa.
public void putAll(Map map) inserta el mapa especificado dentro del mapa.
Eliminar objeto público (clave de objeto) elimina una entrada de acuerdo con la clave especificada.
Public Object get (clave de objeto) devuelve el valor de la clave especificada.
booleano público contiene clave (clave de objeto) busca la clave especificada de este mapa
public Set keySet() devuelve una vista Set que contiene todas las claves
public Set entrySet() devuelve una vista Set con todas las claves y valores.

¿Qué es HashMap?

¿Qué es Hash Map? Es la implementación más popular de la interfaz Map<Key,Value>. Esta estructura de datos se basa en el principio hash.

El principio principal del trabajo de HashMap: hashing

Para comprender qué es un mapa hash y cómo funciona, primero hablemos sobre el hash y las funciones hash. Una función hash es solo una función en un sentido matemático. Entonces, hay algún valor de entrada (un objeto, un dato) y la función lo convierte usando una regla adecuada en valor de salida: un hash. Muy a menudo, el hash es un número hexadecimal de una longitud adecuada. Las reglas de los procesos de conversión pueden ser diferentes, pero están sujetas a los siguientes principios:

Una entrada particular (objeto) tiene un código hash particular.
Si dos objetos son iguales, sus códigos hash también son iguales. Lo opuesto no es verdad.
Si los códigos hash son diferentes, los objetos definitivamente no son iguales.
A veces, diferentes objetos pueden tener el mismo código hash. Es un evento muy poco probable, llamado "colisión" y una función hash de buena calidad debería minimizar la probabilidad de colisiones.

En Java, cada objeto tiene un código hash. Se calcula mediante el método hashCode de la clase Object, clase padre de todos los Objetos Java. Por lo general, los desarrolladores anulan este método para sus propias clases, así como para los métodos equals asociados con él.

HashMap: cómo funciona

Entonces, Class HashMap<K,V>, ya que cada implementación de Map consta de claves y valores. Almacena claves usando principios hash. Dentro de los pares clave-valor de HashMap se almacenan en "cubos", estos cubos juntos construyen una "tabla", una matriz interna de listas vinculadas y su tamaño inicial es 16. HashMap en Java utiliza el código hash de la clave para determinar un depósito en el que debe asignarse el par clave/valor: la característica engañosa de HashMap es que cada celda (depósito) de la tabla [] mantiene no solo un par sino varios. No se almacenan como un objeto explícito (como LinkedList), sino como una cadena implícita. La cadena se crea debido al hecho de que cada par almacena un enlace al siguiente par. Es decir, todos los pares de HashMap están dispersos en 16 cadenas. Cuando coloca un nuevo par en la tabla, se considera el hash de la clave. Este hash no es una función de código hash integrada en el objeto clave. Se considera que está en el rango de 0-15. El par se agrega a la cadena de pares almacenados en el depósito con el índice hash. Este enfoque nos da aceleración de búsqueda. Al buscar un par por clave, no es necesario revisar toda la tabla. Se considera el hash de la clave y solo se comprueba la cadena que está almacenada en la celda con el índice hash. Si hay demasiados pares en HashMap, las cadenas se vuelven demasiado largas. Luego, el tamaño de la matriz aumenta, el hash de todos los objetos almacenados se vuelve a calcular y se dispersan a lo largo de nuevas cadenas.

Declaración de HashMap

Si vas al código HashMap de la clase encontrarás la siguiente declaración:

public class HashMap extends AbstractMap implements Map, Cloneable, Serializable

Donde K es el tipo de claves mantenidas por este mapa y V - el tipo de valores mapeados. Este es un ejemplo de declaración de HashMap con clave Integer y valor de cadena en su código:

HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

métodos HashMap

Aquí está la lista de métodos HashMap.

Object get (clave de objeto) devuelve el valor de la clave especificada;
Object put(Key k, Value v) inserta el mapeo de valor clave en el mapa;
Eliminar objeto (clave de objeto) elimina el mapeo de la clave especificada de este mapa, si está presente;
void clear() elimina todos los pares clave-valor del HashMap;
Object clone() devuelve una copia superficial de esta instancia de HashMap sin clonar las claves y los valores;
boolean containsKey(Object key) devuelve verdadero si la clave especificada se encuentra en el mapa, falso si no lo es;
boolean containsValue(Object Value) devuelve verdadero si la clave especificada se encuentra en el mapa, falso si no lo es;
boolean isEmpty() devuelve verdadero si el mapa está vacío, falso si no lo está;
Set keySet() devuelve el conjunto de claves obtenidas del mapa;
int size() devuelve la cantidad de asignación de clave-valor;
Collection values() devuelve una colección de valores del mapa;
Eliminar objeto (clave de objeto) elimina el par clave-valor de la clave especificada;
void putAll(Map m) copia todos los elementos del mapa al otro mapa.

Ejemplo de Java HashMap

Vamos a crear un programa con Java HashMap Example para demostrar cómo funciona:

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;

public class HashMap {

   public static void main(String[] args) {

       {

           // HashMap declaration
           HashMap<Integer, String> myHashMap = new HashMap<Integer, String>();

           //Adding elements into HashMap
           myHashMap.put(7, "Johnny");
           myHashMap.put(8, "Ivy");
           myHashMap.put(1, "Rick");
           myHashMap.put(4, "Stan");
           myHashMap.put(3, "Kyle");

           //print out the map content using Iterator
           Set set = myHashMap.entrySet();
           Iterator iterator = set.iterator();
           while (iterator.hasNext()) {
               Map.Entry mapEntry = (Map.Entry) iterator.next();
               System.out.print("key: " + mapEntry.getKey() + " value: ");
               System.out.println(mapEntry.getValue());
           }
           System.out.println("get an element from myHashMap via key and print the value out:");
           System.out.println(myHashMap.get(8));
           //print out hashMap on standard way:
           System.out.println(myHashMap);

           // Get values based on key
           String var = myHashMap.get(2);
           //here we'll get null, we don't have such a key
           System.out.println("Value with key 2: " + var);
           var = myHashMap.get(7);
           System.out.println("Value with key 7: " + var);

           // Remove values based on key
           myHashMap.remove(4);
           System.out.println("myHashMap after removing element:");
           System.out.println(myHashMap);
           myHashMap.clear();
           System.out.println("myHashMap after total clearing:");
           System.out.println(myHashMap);
       }

   }
}

El resultado de ejecutar el programa:

key: 1 value: Rick
key: 3 value: Kyle
key: 4 value: Stan
key: 7 value: Johnny
key: 8 value: Ivy
get an element from myHashMap via key and print the value out:
Ivy
{1=Rick, 3=Kyle, 4=Stan, 7=Johnny, 8=Ivy}
Value with key 2: null
Value with key 7: Johnny
myHashMap after removing element:
{1=Rick, 3=Kyle, 7=Johnny, 8=Ivy}
myHashMap after total clearing:
{}

ÁrbolMapa

TreeMap en Java también implementa la interfaz Map<Key,Value>, pero se basa en una estructura de datos de árbol rojo-negro. Un árbol consta de "nodos" y líneas que conectan nodos - ramas". El nodo "raíz" está en la parte superior del árbol. Desde la raíz, puede haber ramas y nodos. Es una estructura jerárquica, puede pensar en estos nodos como "hijos" de la raíz. El nodo hijo puede tener sus propios hijos - nodos inferiores. Los nodos sin hijos se llaman "nodos finales" u "hojas". Un árbol binario es un árbol, donde cada nodo tiene cero, uno , o dos niños El árbol de búsqueda binaria es una estructura, donde cada nodo interno almacena una clave y, a veces, un valor asociado, y tiene dos subárboles distintos ("izquierda" y "derecha"). Un árbol de búsqueda binario autoequilibrado es un árbol de búsqueda binario basado en nodos que mantiene automáticamente su altura (número máximo de niveles por debajo de la raíz) pequeña frente a las inserciones y eliminaciones arbitrarias de elementos. Un árbol rojo-negro es un árbol binario equilibrado con las propiedades:

Cada nodo es rojo o negro
La raíz siempre es negra.
Cada hoja es un nodo NIL (tipo de vacío, nulo) y es negro
Si un nodo es rojo, sus hijos son definitivamente negros.
Cada camino simple de un nodo a una hoja descendiente contiene el mismo número de nodos negros.

Características de un TreeMap

Un TreeMap usa una estructura de datos de árbol para almacenar las claves como nodos y ordena las claves usando el algoritmo Red-Black Tree. Así, TreeMap mantiene sus entradas ordenadas según el orden natural de sus claves. Para los números, el orden natural es ascendente, para las cadenas, el orden alfabético. Puede usar un comparador si necesita cambiar la lógica de pedido. Ordenar objetos de forma natural es una gran ventaja de TreeMap, así como encontrar algunos objetos usando diferentes filtros y condiciones.

métodos TreeMap

Object get(Clave de objeto) devuelve el valor de la clave correspondiente;
Objeto puesto (clave de objeto, valor de objeto) inserta una asignación en un mapa;
Eliminar objeto (clave de objeto) elimina la asignación de esta clave si el TreeMap lo contiene;
boolean containsKey(Object key) devuelve verdadero si este mapa contiene un mapeo para la clave especificada;
boolean containsValue(Object value) devuelve verdadero si TreeMap asigna una o más claves al valor especificado;
Object firstKey() devuelve la primera clave actualmente en el mapa ordenado;
Object lastKey() devuelve la última clave actualmente en el mapa ordenado;
void putAll(Map map) copia todas las asignaciones del mapa especificado al mapa;
Set entrySet() devuelve una vista establecida de las asignaciones
int size() devuelve la cantidad de asignaciones de clave-valor
Valores de colección () devuelve una vista de colección de los valores
Object clone() devuelve una copia superficial del TreeMap
void clear() elimina todas las asignaciones del TreeMap
SortedMap headMap(Object key_value) devuelve una vista de la parte del mapa menor que el parámetro key_value
Set keySet() devuelve una vista Set de las claves contenidas en el diagrama de árbol
SortedMap subMap(K fromKey, K toKey) devuelve una vista de la parte de este mapa cuyas claves van desde fromKey, inclusive, hasta toKey, exclusiva
Object firstKey() devuelve la primera clave del TreeMap.

Ejemplo de mapa de árbol

import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;

public class TreeMapExample {

   public static void main(String args[]) {

       //TreeMap declaration
       TreeMap<Integer, String> myTreeMap = new TreeMap<Integer, String>();

       //put elements to TreeMap
       myTreeMap.put(1, "Stuart");
       myTreeMap.put(23, "Michael");
       myTreeMap.put(7, "Johnny");
       myTreeMap.put(5, "Ivy");
       myTreeMap.put(2, "Alex");

       //Display and print out myTreeMap using Iterator
       Set set = myTreeMap.entrySet();
       Iterator iterator = set.iterator();
       while (iterator.hasNext()) {
           Map.Entry myEntry = (Map.Entry) iterator.next();
           System.out.print("key: " + myEntry.getKey() + " value: ");
           System.out.println(myEntry.getValue());
       }
       //TreeMap printed in classical way
       System.out.println(myTreeMap);
       //removing an element with the key =2
       myTreeMap.remove(2);
       //myTreeMap after removing:
       System.out.println(myTreeMap);
   }
}

El resultado de ejecutar el programa:

key: 1 value: Stuart
key: 2 value: Alex
key: 5 value: Ivy
key: 7 value: Johnny
key: 23 value: Michael
{1=Stuart, 2=Alex, 5=Ivy, 7=Johnny, 23=Michael}
{1=Stuart, 5=Ivy, 7=Johnny, 23=Michael}

LinkedHashMap

LinkedHashMap es una estructura de datos que combina listas enlazadas y mapas hash. De hecho, LinkedHashMap amplía la clase HashMap e implementa la interfaz Map, pero ¿qué tienen las listas enlazadas? La declaración de LinkedHashMap:

Map <Integer, String> linkedHashMap = new LinkedHashMap <Integer, String>();

Este nuevo LinkedHashMap hereda propiedades de HashMap (como tabla, factor de carga, umbral, tamaño, conjunto de entrada), también obtiene dos propiedades especiales:

header es el encabezado de una lista doblemente enlazada. Durante la inicialización, se indica a sí mismo
accessOrder indica cómo obtener acceso a los elementos mediante el iterador. Si es verdadero, en el orden del último acceso. Si es falso, el acceso será en el orden en que se insertaron los elementos.

Esta lista enlazada define el orden de las iteraciones. Por lo general, es el orden de inserción de claves en el mapa.

Métodos LinkedHashMap

Object get (clave de objeto) devuelve el valor al que se asigna la clave especificada, o nulo si este mapa no contiene ninguna asignación para la clave
void clear() elimina todas las asignaciones del mapa.
boolean containsKey (clave de objeto) devuelve verdadero si el elemento especificado está asignado por una o más claves
boolean removeEldestEntry(Map.Entry eldest) devuelve verdadero si el mapa elimina su entrada más antigua del mapa
Set<Map.Entry<K,V>> entrySet() devuelve una vista de conjunto de las asignaciones contenidas en este mapa
void forEach(BiConsumer<? super K,? super V> action) realiza la acción dada para cada entrada en este mapa hasta que todas las entradas hayan sido procesadas o la acción genere una excepción.
Object getOrDefault(Object key, V defaultValue) devuelve el valor al que se asigna la clave especificada. Si el mapa no contiene una asignación para la clave, devuelve defaultValue.
Set<K> keySet() devuelve una vista Set de las claves contenidas en el mapa
boolean removeEldestEntry(Map.Entry<K,V> eldest) devuelve verdadero si este mapa debe eliminar su entrada más antigua
void replaceAll(BiFunction<? super K,? super V,? extends V> function) reemplaza cada valor de entrada con el resultado de invocar la función dada en esa entrada hasta que todas las entradas hayan sido procesadas o la función arroje una excepción.
Collection<v>values() devuelve una vista de colección de los valores contenidos en el mapa

Ejemplo de LinkedHashMap

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
   public class HashLinkedListExample {
       public static void main(String args[]) {
           // LinkedHashMap Declaration
           LinkedHashMap<Integer, String> myLinkedHashMap =
                   new LinkedHashMap<Integer, String>();

           //Adding elements into LinkedHashMap
           myLinkedHashMap.put(7, "Johnny");
           myLinkedHashMap.put(12, "Rick");
           myLinkedHashMap.put(1, "Kyle");
           myLinkedHashMap.put(5, "Percy");
           myLinkedHashMap.put(85, "Sebastian");

           // Generate a Set of entries
           Set set = myLinkedHashMap.entrySet();

           // Display and print out the nodes  of LinkedHashMap
           Iterator iterator = set.iterator();
           while(iterator.hasNext()) {
               Map.Entry me = (Map.Entry)iterator.next();
               System.out.print("key: "+ me.getKey() +
                       " value: "+me.getValue()+"\n");
           }
           //print out HashLinkedMap on standard way:
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(21, "Ivy");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.remove(12);
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(12, "Ronny");
           System.out.println(myLinkedHashMap);
           myLinkedHashMap.put(1, "Stan");
           System.out.println(myLinkedHashMap);
       }
   }

Aquí creamos un nuevo LinkedHashMap, agregando cinco elementos, luego lo imprimimos usando un iterador y de una manera clásica. Como puede ver, LinkedHashMap mantiene el orden de inserción. Después de eso, eliminamos un elemento de nuestro Mapa, luego agregamos uno nuevo y luego, un elemento más con la clave, que ya está en el mapa. Reemplaza el antiguo valor asignado a esta clave. El resultado de ejecutar el programa:

key: 7 value: Johnny
key: 12 value: Rick
key: 1 value: Kyle
key: 5 value: Percy
key: 85 value: Sebastian
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian}
{7=Johnny, 12=Rick, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy}
{7=Johnny, 1=Kyle, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}
{7=Johnny, 1=Stan, 5=Percy, 85=Sebastian, 21=Ivy, 12=Ronny}

Comparación de HashMap, TreeMap, LinkedHashMap

HashMap, TreeMap y LinkedHashMap son las implementaciones de las interfaces Map. HashMap y LinkedHashMap son estructuras de datos que codifican claves. TreeMap utiliza el orden natural de sus claves para organizar un árbol de búsqueda. Orden:

HashMap no mantiene ningún orden.
TreeMap ordena las entradas en orden ascendente de claves.
LinkedHashMap mantiene el orden de inserción.

Claves nulas:

HashMap y LinkedHashMap permiten tener una clave nula.
LinkedHashMap no permite claves nulas en caso de que las claves utilicen un orden natural o Comparator no admita la comparación en leyes nulas.

Veamos un ejemplo de mapa de Java que incluye las tres implementaciones revisadas en este artículo:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class CompMapImpl {


    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        hashMap.put(5, "Ivy");
        hashMap.put(null, "Joker");
        hashMap.put(1, "First");
        hashMap.put(2, "Kyle");
        hashMap.put(-2, "Paul");
        hashMap.put(3, "Sandy");


        treeMap.put(5, "Ivy");
        //treeMap.put(null,"Joker");
        treeMap.put(1, "First");
        treeMap.put(2, "Kyle");
        treeMap.put(-2, "Paul");
        treeMap.put(3, "Sandy");

        linkedHashMap.put(5, "Ivy");
        linkedHashMap.put(null, "Joker");
        linkedHashMap.put(1, "First");
        linkedHashMap.put(2, "Kyle");
        linkedHashMap.put(-2, "Paul");
        linkedHashMap.put(3, "Sandy");
        System.out.println("HashMap");
        System.out.println(hashMap);
        System.out.println("TreeMap");
        System.out.println(treeMap);
        System.out.println("LinkedHashMap");
        System.out.println(linkedHashMap);


        LinkedHashMap<String, String> linkedHashMap1= new LinkedHashMap<> ();
        linkedHashMap1.put(null, "Andy");
        System.out.println(linkedHashMap1);
    }
}

Este es el resultado de ejecutar este programa:

HashMap
{null=Joker, 1=First, -2=Paul, 2=Kyle, 3=Sandy, 5=Ivy}
TreeMap
{-2=Paul, 1=First, 2=Kyle, 3=Sandy, 5=Ivy}
LinkedHashMap
{5=Ivy, null=Joker, 1=First, 2=Kyle, -2=Paul, 3=Sandy}
{null=Andy}

Como podemos ver, el orden de los elementos en HashMap no es obvio, en treeMap depende de las claves, en LinkedHashMap se trata del orden de inserción. Si tratamos de poner una clave nula en linkedHashMap, obtendremos NullPointerException, pero en linkedHashMap1, donde las claves son String, podemos hacerlo. Un mapa hash es la mejor implementación de mapas de propósito general. Proporciona la máxima velocidad de búsqueda, almacenamiento rápido y operaciones de recuperación, pero debe recordar su ordenación caótica. Un mapa hash vinculado hereda las ventajas de HashMap y obtiene un pedido de claves. Sin embargo, contiene linkedList, que es relativamente costoso en términos de memoria. es más lento que HashMap en la búsqueda y un poco más lento para agregar/eliminar debido a que mantiene la lista vinculada. Un mapa de árbol almacena claves ordenadas en orden ascendente. Sin embargo, Para reforzar lo que aprendió, le sugerimos que vea una lección en video de nuestro Curso de Java

Más lectura:
Cómo actualizar el valor de una clave existente en HashMap Método HashMap getOrDefault en Java Método KeySet en java.util.Map