En Java, HashMap es parte de la colección de Java desde Java 1.2. Esta clase se encuentra en java.util paquete. Proporciona la implementación básica de la interfaz Map de Java. HashMap en Java almacena los datos en pares (clave, valor) y puede acceder a ellos mediante un índice de otro tipo (por ejemplo, un número entero). Un objeto se utiliza como clave (índice) para otro objeto (valor). Si intenta insertar la clave duplicada en HashMap, reemplazará el elemento de la clave correspondiente.
¿Qué es HashMap?
Mapa Hash de Java es parecido a Tabla de picadillo , pero no está sincronizado. También permite almacenar las claves nulas, pero solo debe haber un objeto de clave nula y puede haber cualquier número de valores nulos. Esta clase no ofrece garantías en cuanto al orden del mapa. Para usar esta clase y sus métodos, necesita importar java.util.HashMap paquete o su superclase.
Tabla de contenidos
- ¿Qué es HashMap?
- Ejemplos de HashMap de Java
- Declaración HashMap
- Jerarquía de Java HashMap
- Creando HashMap en Java
- Constructores de mapas hash de Java
- Realizar varias operaciones en HashMap
- Complejidad de HashMap en Java
- Estructura interna de HashMap
- Ventajas y desventajas de Java HashMap
Ejemplos de HashMap de Java
A continuación se muestra la implementación de un ejemplo de Java HashMap:
Java
// Java program to illustrate HashMap class> // of java.util package> // Importing HashMap class> import> java.util.HashMap;> // Main class> public> class> GFG {> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Create an empty hash map by declaring object> >// of string and integer type> >HashMap map =>new> HashMap();> >// Adding elements to the Map> >// using standard put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Print size and content of the Map> >System.out.println(>'Size of map is:- '> >+ map.size());> >// Printing elements in object of Map> >System.out.println(map);> >// Checking if a key is present and if> >// present, print value by passing> >// random element> >if> (map.containsKey(>'vishal'>)) {> >// Mapping> >Integer a = map.get(>'vishal'>);> >// Printing value for the corresponding key> >System.out.println(>'value for key'> >+>' 'vishal' is:- '> + a);> >}> >}> }> |
>
>Producción
Size of map is:- 3 {vaibhav=20, vishal=10, sachin=30} value for key 'vishal' is:- 10> HashMap Declaración
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Parámetros:
Se necesitan dos parámetros, a saber, los siguientes:
- El tipo de claves mantenidas por este mapa.
- El tipo de valores asignados.
Nota: K eys y value no pueden ser tipos de datos primitivos. La clave en Hashmap es válida si implementa método hashCode() y igual() , también debe ser inmutable (objeto personalizado inmutable) para que el código hash y la igualdad permanezcan constantes. El valor en hashmap puede ser cualquier clase contenedora, objetos personalizados, matrices, cualquier tipo de referencia o incluso nulo.
Por ejemplo : Hashmap puede tener una matriz como valor pero no como clave.
HashMap en implementos Java Serializable , Clonable , Mapa interfaces.Java HashMap se extiende ResumenMapa clase. Las subclases directas son LinkedHashMap y Razones del estado de la impresora .
Jerarquía de Java HashMap

Características de Java HashMap
Un HashMap es una estructura de datos que se utiliza para almacenar y recuperar valores basados en claves. Algunas de las características clave de un hashmap incluyen:
- Tiempo de acceso rápido : HashMaps proporciona acceso en tiempo constante a los elementos, lo que significa que la recuperación e inserción de elementos son muy rápidas, generalmente con una complejidad de tiempo O (1).
- Utiliza la función hash : HashMaps utiliza una función hash para asignar claves a índices en una matriz. Esto permite una búsqueda rápida de valores basados en claves.
- Almacena pares clave-valor: Cada elemento de un HashMap consta de un par clave-valor. La clave se utiliza para buscar el valor asociado.
- Admite claves y valores nulos : HashMaps permite valores y claves nulos. Esto significa que se puede utilizar una clave nula para almacenar un valor y se puede asociar un valor nulo con una clave.
- No ordenado: Los HashMaps no están ordenados, lo que significa que no se conserva el orden en el que se agregan los elementos al mapa. Sin embargo, LinkedHashMap es una variación de HashMap que conserva el orden de inserción.
- Permite duplicados : HashMaps permite valores duplicados, pero no claves duplicadas. Si se agrega una clave duplicada, se sobrescribe el valor anterior asociado con la clave.
- Hilo inseguro : Los HashMaps no son seguros para subprocesos, lo que significa que si varios subprocesos acceden al mismo mapa hash simultáneamente, puede provocar inconsistencias en los datos. Si se requiere seguridad para subprocesos, se puede utilizar ConcurrentHashMap.
- Capacidad y factor de carga. : Los HashMaps tienen una capacidad, que es la cantidad de elementos que puede contener, y un factor de carga, que es la medida de qué tan lleno puede estar el hashmap antes de cambiar su tamaño.
Creando HashMap en Java
Entendamos cómo podemos crear HashMap en Java con el ejemplo que se menciona a continuación:
Java
// Java Program to Create> // HashMap in Java> import> java.util.HashMap;> // Driver Class> public> class> ExampleHashMap {> >// main function> >public> static> void> main(String[] args) {> > >// Create a HashMap> >HashMap hashMap =>new> HashMap();> > >// Add elements to the HashMap> >hashMap.put(>'John'>,>25>);> >hashMap.put(>'Jane'>,>30>);> >hashMap.put(>'Jim'>,>35>);> > >// Access elements in the HashMap> >System.out.println(hashMap.get(>'John'>));> >// Output: 25> > >// Remove an element from the HashMap> >hashMap.remove(>'Jim'>);> > >// Check if an element is present in the HashMap> >System.out.println(hashMap.containsKey(>'Jim'>));> >// Output: false> > >// Get the size of the HashMap> >System.out.println(hashMap.size());> >// Output: 2> >}> }> |
golpear más si
>
>Producción
25 false 2>
Constructores de mapas hash de Java
HashMap proporciona 4 constructores y el modificador de acceso de cada uno es público, que se enumeran a continuación:
- Mapa Hash()
- HashMap (int capacidad inicial)
- HashMap (int capacidad inicial, factor de carga flotante)
- HashMap (mapa del mapa)
Ahora analizamos los constructores anteriores uno por uno además de implementarlos con la ayuda de programas Java limpios.
1. Mapa Hash()
Es el constructor predeterminado el que crea una instancia de HashMap con una capacidad inicial de 16 y un factor de carga de 0,75.
Sintaxis:
HashMap hm = new HashMap();>
Ejemplo
Java
// Java program to Demonstrate the HashMap() constructor> // Importing basic required classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap();> >// Adding elements using put method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display mapping of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display mapping of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Producción
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 2. HashMap (int capacidad inicial)
Crea una instancia de HashMap con un capacidad inicial especificada y factor de carga de 0.75.
Sintaxis:
HashMap hm = new HashMap(int initialCapacity);>
Ejemplo
Java
// Java program to Demonstrate> // HashMap(int initialCapacity) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> AddElementsToHashMap {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap(>10>);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>2>);> >// Adding elements to object of HashMap> >// using put method> >// HashMap 1> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// HashMap 2> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Printing elements of HashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Printing elements of HashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Producción
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 3. HashMap (int capacidad inicial, factor de carga flotante)
Crea una instancia de HashMap con una capacidad inicial especificada y un factor de carga especificado.
Sintaxis:
HashMap hm = new HashMap(int initialCapacity, float loadFactor);>
Ejemplo
Java
// Java program to Demonstrate> // HashMap(int initialCapacity,float loadFactor) Constructor> // Importing basic classes> import> java.io.*;> import> java.util.*;> // Main class> // To add elements to HashMap> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// No need to mention the generic type twice> >HashMap hm1> >=>new> HashMap(>5>,>0>.75f);> >// Initialization of a HashMap using Generics> >HashMap hm2> >=>new> HashMap(>3>,>0>.5f);> >// Add Elements using put() method> >// Custom input elements> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >hm2.put(>4>,>'four'>);> >hm2.put(>5>,>'five'>);> >hm2.put(>6>,>'six'>);> >// Print and display elements in object of hashMap 1> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >// Print and display elements in object of hashMap 2> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Producción
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {4=four, 5=five, 6=six}> 4. HashMap (mapa del mapa)
Crea una instancia de HashMap con las mismas asignaciones que el mapa especificado.
HashMap hm = nuevo HashMap (mapa del mapa);
Java
// Java program to demonstrate the> // HashMap(Map map) Constructor> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >Map hm1 =>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'one'>);> >hm1.put(>2>,>'two'>);> >hm1.put(>3>,>'three'>);> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap(hm1);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> > >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Producción
Mappings of HashMap hm1 are : {1=one, 2=two, 3=three} Mapping of HashMap hm2 are : {1=one, 2=two, 3=three}> Realizar varias operaciones en HashMap
1. Agregar elementos en HashMap en Java
Para agregar un elemento al mapa, podemos usar el poner() método. Sin embargo, el orden de inserción no se conserva en Hashmap. Internamente, para cada elemento, se genera un hash separado y los elementos se indexan en función de este hash para hacerlo más eficiente.
Java
// Java program to add elements> // to the HashMap> import> java.io.*;> import> java.util.*;> class> AddElementsToHashMap {> >public> static> void> main(String args[])> >{> >// No need to mention the> >// Generic type twice> >HashMap hm1 =>new> HashMap();> >// Initialization of a HashMap> >// using Generics> >HashMap hm2> >=>new> HashMap();> >// Add Elements using put method> >hm1.put(>1>,>'Geeks'>);> >hm1.put(>2>,>'For'>);> >hm1.put(>3>,>'Geeks'>);> >hm2.put(>1>,>'Geeks'>);> >hm2.put(>2>,>'For'>);> >hm2.put(>3>,>'Geeks'>);> >System.out.println(>'Mappings of HashMap hm1 are : '> >+ hm1);> >System.out.println(>'Mapping of HashMap hm2 are : '> >+ hm2);> >}> }> |
>
>Producción
Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks} Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}> 2. Cambiar elementos en HashMap en Java
Después de agregar los elementos, si deseamos cambiar el elemento, podemos hacerlo agregando nuevamente el elemento con el poner() método. Dado que los elementos del mapa se indexan mediante claves, el valor de la clave se puede cambiar simplemente insertando el valor actualizado de la clave que deseamos cambiar.
Java
texto de ajuste css
// Java program to change> // elements of HashMap> import> java.io.*;> import> java.util.*;> class> ChangeElementsOfHashMap {> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >HashMap hm> >=>new> HashMap();> >// Change Value using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'Geeks'>);> >hm.put(>3>,>'Geeks'>);> >System.out.println(>'Initial Map '> + hm);> >hm.put(>2>,>'For'>);> >System.out.println(>'Updated Map '> + hm);> >}> }> |
>
>Producción
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Eliminación de elementos de Java HashMap
Para eliminar un elemento del Mapa, podemos utilizar el eliminar() método. Este método toma el valor de la clave y elimina la asignación de una clave de este mapa si está presente en el mapa.
Java
// Java program to remove> // elements from HashMap> import> java.io.*;> import> java.util.*;> class> RemoveElementsOfHashMap{> >public> static> void> main(String args[])> >{> >// Initialization of a HashMap> >Map hm> >=>new> HashMap();> >// Add elements using put method> >hm.put(>1>,>'Geeks'>);> >hm.put(>2>,>'For'>);> >hm.put(>3>,>'Geeks'>);> >hm.put(>4>,>'For'>);> >// Initial HashMap> >System.out.println(>'Mappings of HashMap are : '> >+ hm);> >// remove element with a key> >// using remove method> >hm.remove(>4>);> >// Final HashMap> >System.out.println(>'Mappings after removal are : '> >+ hm);> >}> }> |
>
>Producción
Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For} Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}> 4. Recorrido de Java HashMap
Podemos usar la interfaz Iterator para recorrer cualquier estructura del Collection Framework. Dado que los iteradores funcionan con un tipo de datos, utilizamos Entry para resolver los dos tipos separados en un formato compatible. Luego, usando el método next() imprimimos las entradas de HashMap.
Java
// Java program to traversal a> // Java.util.HashMap> import> java.util.HashMap;> import> java.util.Map;> public> class> TraversalTheHashMap {> >public> static> void> main(String[] args)> >{> >// initialize a HashMap> >HashMap map =>new> HashMap();> >// Add elements using put method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> >// Iterate the map using> >// for-each loop> >for> (Map.Entry e : map.entrySet())> >System.out.println(>'Key: '> + e.getKey()> >+>' Value: '> + e.getValue());> >}> }> |
>
león comparado con un tigre
>Producción
Key: vaibhav Value: 20 Key: vishal Value: 10 Key: sachin Value: 30>
Complejidad de HashMap en Java
HashMap proporciona una complejidad de tiempo constante para operaciones básicas, get y put, si la función hash está escrita correctamente y dispersa los elementos adecuadamente entre los depósitos. La iteración sobre HashMap depende de la capacidad de HashMap y del número de pares clave-valor. Básicamente, es directamente proporcional a la capacidad + tamaño. La capacidad es la cantidad de depósitos en HashMap. Por lo tanto, no es una buena idea mantener inicialmente una gran cantidad de depósitos en HashMap.
| Métodos | Complejidad del tiempo | Complejidad espacial |
|---|---|---|
| Agregar elementos en HashMap | O(1) | EN) |
| Eliminar elemento de HashMap | O(1) | EN) |
| Extrayendo elementos de Java | O(1) | EN) |
Características importantes de HashMap
Para acceder a un valor es necesario conocer su clave. HashMap se conoce como HashMap porque utiliza una técnica llamada Hashing. hash es una técnica para convertir una Cadena grande en una Cadena pequeña que representa la misma Cadena. Un valor más corto ayuda a la indexación y a realizar búsquedas más rápidas. Conjunto de hash También usa HashMap internamente.
Algunas características importantes de HashMap son:
- HashMap es parte del paquete java.util.
- HashMap extiende una clase abstracta AbstractMap que también proporciona una implementación incompleta de la interfaz Map.
- También implementa un Clonable y Serializable interfaces. K y V en la definición anterior representan clave y valor respectivamente.
- HashMap no permite claves duplicadas pero sí valores duplicados. Eso significa que una sola clave no puede contener más de 1 valor, pero más de 1 clave puede contener un solo valor.
- HashMap también permite una clave nula, pero solo una vez, y múltiples valores nulos.
- Esta clase no ofrece garantías en cuanto al orden del mapa; en particular, no garantiza que el orden se mantendrá constante en el tiempo. Es más o menos similar a HashTable pero no está sincronizado.
Estructura interna de HashMap
Internamente, HashMap contiene una matriz de Node y un nodo se representa como una clase que contiene 4 campos:
- hash int
- tecla K
- valor V
- Nodo siguiente
Se puede ver que el nodo contiene una referencia a su propio objeto. Entonces es una lista vinculada.
Mapa Hash:

Nodo:

Rendimiento de HashMap
El rendimiento de HashMap depende de 2 parámetros que se denominan a continuación:
- Capacidad inicial
- Factor de carga
1. Capacidad inicial – Es la capacidad de HashMap en el momento de su creación (es la cantidad de depósitos que un HashMap puede contener cuando se crea una instancia de HashMap). En Java, inicialmente es 2^4=16, lo que significa que puede contener 16 pares clave-valor.
2. Factor de carga – Es el valor porcentual de la capacidad después del cual se aumentará la capacidad de Hashmap (es el porcentaje de llenado de los depósitos después del cual se realiza el refrito). En Java, es 0,75f de forma predeterminada, lo que significa que la repetición se realiza después de llenar el 75% de la capacidad.
3. Umbral – Es el producto del Factor de Carga y la Capacidad Inicial. En Java, de forma predeterminada, es (16 * 0,75 = 12). Es decir, el Rehashing se lleva a cabo después de insertar 12 pares clave-valor en el HashMap.
4. Refrito – Es el proceso de duplicar la capacidad del HashMap después de que alcanza su Umbral. En Java, HashMap continúa repitiendo (de forma predeterminada) en la siguiente secuencia: 2^4, 2^5, 2^6, 2^7,…. pronto.
Si la capacidad inicial se mantiene más alta, nunca se realizará el refrito. Pero mantenerlo más alto aumenta la complejidad temporal de la iteración. Por lo tanto, se debe elegir muy inteligentemente para aumentar el rendimiento. Se debe tener en cuenta el número esperado de valores para establecer la capacidad inicial. El valor del factor de carga más generalmente preferido es 0,75, lo que proporciona una buena relación entre los costos de tiempo y espacio. El valor del factor de carga varía entre 0 y 1.
Nota: Desde Java 8 en adelante, Java comenzó a usar Self Balancing BST en lugar de una lista vinculada para encadenar. La ventaja del bst autoequilibrado es que obtenemos el peor de los casos (cuando cada clave se asigna a la misma ranura) el tiempo de búsqueda es O (Log n).
HashMap sincronizado
Como se dice, HashMap no está sincronizado, es decir, varios subprocesos pueden acceder a él simultáneamente. Si varios subprocesos acceden a esta clase simultáneamente y al menos un subproceso la manipula estructuralmente, entonces es necesario sincronizarlo externamente. Se realiza sincronizando algún objeto que encapsula el mapa. Si no existe tal objeto, se puede incluir en Collections.synchronizedMap() para sincronizar HashMap y evitar el acceso no sincronizado accidental. Como en el siguiente ejemplo:
Map m = Collections.synchronizedMap(new HashMap(...));>
Ahora el Map m está sincronizado. Los iteradores de esta clase son a prueba de fallos si se realiza alguna modificación de la estructura después de la creación del iterador, de cualquier forma excepto a través del método remove del iterador. En caso de falla de un iterador, arrojará ConcurrentModificationException.
Aplicaciones de HashMap:
HashMap es principalmente la implementación de hash. Es útil cuando necesitamos una implementación eficiente de operaciones de búsqueda, inserción y eliminación. por favor refiérase a aplicaciones de hash para detalles.
Métodos en HashMapassociate
- k – El tipo de claves en el mapa.
- EN – El tipo de valores asignados en el mapa.
| Método | Descripción |
|---|---|
| claro() | Elimina todas las asignaciones de este mapa. |
| clon() | Devuelve una copia superficial de esta instancia de HashMap: las claves y los valores en sí no están clonados. |
| calcular (tecla K, BiFunción ? ¿súper V? extiende V> función de reasignación) | Intenta calcular una asignación para la clave especificada y su valor asignado actual (o nulo si no hay ninguna asignación actual). |
| calcularSiAbsent(tecla K, Función Súper K,? extiende V> función de mapeo) | Si la clave especificada aún no está asociada con un valor (o está asignada a nulo), intenta calcular su valor usando la función de mapeo dada y lo ingresa en este mapa a menos que sea nulo. |
| calcularSiPresente(tecla K, BiFunción ? ¿súper V? extiende V> función de reasignación) | Si el valor de la clave especificada está presente y no es nulo, intenta calcular una nueva asignación dada la clave y su valor asignado actual. |
| contiene clave (clave de objeto) | Devuelve verdadero si este mapa contiene una asignación para la clave especificada. |
| contieneValor(Valor del objeto) | Devuelve verdadero si este mapa asigna una o más claves al valor especificado. |
| conjunto de entrada() | Devuelve una vista de conjunto de las asignaciones contenidas en este mapa. |
| obtener (clave de objeto) | Devuelve el valor al que está asignada la clave especificada, o nulo si este mapa no contiene ninguna asignación para la clave. |
| esta vacio() | Devuelve verdadero si este mapa no contiene asignaciones clave-valor. |
| juego de llaves() | Devuelve una vista de conjunto de las claves contenidas en este mapa. |
| fusionar (tecla K, valor V, BiFunción ? ¿súper V? extiende V> función de reasignación) | Si la clave especificada aún no está asociada con un valor o está asociada con un valor nulo, asóciela con el valor no nulo dado. |
| poner (tecla K, valor V) | Asocia el valor especificado con la clave especificada en este mapa. |
| ponerTodo(Mapa m) | Copia todas las asignaciones del mapa especificado a este mapa. |
| eliminar (clave de objeto) | Elimina la asignación para la clave especificada de este mapa, si está presente. |
| tamaño() | Devuelve el número de asignaciones clave-valor en este mapa. |
| valores() | Devuelve una vista de Colección de los valores contenidos en este mapa. |
Métodos heredados de la clase java.util.AbstractMap
| MÉTODO | DESCRIPCIÓN |
|---|---|
| es igual() | Compara el objeto especificado con este mapa para determinar la igualdad. |
| código hash() | Devuelve el valor del código hash para este mapa. |
| Encadenar() | Devuelve una representación de cadena de este mapa. |
Métodos heredados de la interfaz java.util.Map
| MÉTODO | DESCRIPCIÓN |
|---|---|
| es igual() | Compara el objeto especificado con este mapa para determinar la igualdad. |
| para cada uno (acción BiConsumer) | Realiza la acción dada para cada entrada en este mapa hasta que se hayan procesado todas las entradas o la acción genere una excepción. |
| getOrDefault(Clave de objeto, V valor predeterminado) | Devuelve el valor al que está asignada la clave especificada, o defaultValue si esta asignación no contiene ninguna asignación para la clave. |
| código hash() | Devuelve el valor del código hash para este mapa. |
| putIfAbsent (tecla K, valor V) | Si la clave especificada aún no está asociada con un valor (o está asignada a nulo), la asocia con el valor dado y devuelve nulo; de lo contrario, devuelve el valor actual. |
| eliminar (clave del objeto, valor del objeto) | Elimina la entrada para la clave especificada solo si actualmente está asignada al valor especificado. |
| reemplazar (tecla K, valor V) | Reemplaza la entrada de la clave especificada solo si actualmente está asignada a algún valor. |
| reemplazar (tecla K, V valor antiguo, V valor nuevo) | Reemplaza la entrada de la clave especificada solo si actualmente está asignada al valor especificado. |
| reemplazar todo (función BiFunction) | Reemplaza el valor de cada entrada con el resultado de invocar la función dada en esa entrada hasta que se hayan procesado todas las entradas o la función genere una excepción. |
Ventajas de Java HashMap
- Recuperación rápida: HashMaps proporciona acceso constante en tiempo a los elementos, lo que significa que la recuperación e inserción de elementos es muy rápida.
- Almacenamiento eficiente : HashMaps utiliza una función hash para asignar claves a índices en una matriz. Esto permite una búsqueda rápida de valores basados en claves y un almacenamiento eficiente de datos.
- Flexibilidad : HashMaps permite claves y valores nulos y puede almacenar pares clave-valor de cualquier tipo de datos.
- Fácil de usar : HashMaps tiene una interfaz simple y se puede implementar fácilmente en Java.
- Adecuado para grandes conjuntos de datos : HashMaps puede manejar grandes conjuntos de datos sin ralentizarse.
Desventajas de Java HashMap
- desordenado : Los HashMaps no están ordenados, lo que significa que no se conserva el orden en que se agregan los elementos al mapa.
- No es seguro para subprocesos : Los HashMaps no son seguros para subprocesos, lo que significa que si varios subprocesos acceden al mismo mapa hash simultáneamente, puede provocar inconsistencias en los datos.
- El rendimiento puede degradarse : En algunos casos, si la función hash no se implementa correctamente o si el factor de carga es demasiado alto, el rendimiento de un HashMap puede degradarse.
- Más complejo que matrices o listas : HashMaps puede ser más complejo de entender y usar que simples matrices o listas, especialmente para principiantes.
- Mayor uso de memoria : Dado que HashMaps usa una matriz subyacente, pueden usar más memoria que otras estructuras de datos como matrices o listas. Esto puede ser una desventaja si le preocupa el uso de la memoria.
Además, lea
- Hashmap vs mapa de árbol
- Hashmap y HashTable
- Artículos recientes sobre Java HashMap
Preguntas frecuentes sobre Java HashMap
1. ¿Qué es un HashMap en Java?
HashMap en Java es la clase del marco de colección que puede almacenar pares clave-valor en su interior.
2. ¿Por qué utilizar HashMap en Java?
HashMap en Java se utiliza para almacenar pares clave-valor donde cada clave es única.
3. ¿Cuál es el beneficio de HashMap?
HashMap se utiliza porque proporciona características como:
- Recuperación rápida
- Almacenamiento eficiente
- Flexible de usar
- Fácil de usar
- Adecuado para grandes conjuntos de datos