Mapa hash de Java

En este tutorial, aprenderemos sobre la clase Java HashMap y sus diversas operaciones con la ayuda de ejemplos.

El HashMap La clase del marco de colecciones de Java proporciona la funcionalidad de la estructura de datos de la tabla hash.

Almacena elementos en clave/valor pares Aquí, claves son identificadores únicos que se utilizan para asociar cada valor en un mapa.

El HashMap La clase implementa la interfaz Mapa.

Crear un HashMap

Para crear un mapa hash, debemos importar el java.util.HashMap paquete primero. Una vez que importamos el paquete, así es como podemos crear hashmaps en Java.

// hashMap creation with 8 capacity and 0.6 load factor
HashMap<K, V> numbers = new HashMap<>();

En el código anterior, hemos creado un hashmap llamado numbers . Toma, K representa el tipo de clave y V representa el tipo de valores. Por ejemplo,

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

Aquí, el tipo de claves es String y el tipo de valores es Integer .

Ejemplo 1:Crear HashMap en Java

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    // create a hashmap
    HashMap<String, Integer> languages = new HashMap<>();

    // add elements to hashmap
    languages.put("Java", 8);
    languages.put("JavaScript", 1);
    languages.put("Python", 3);
    System.out.println("HashMap: " + languages);
  }
}

Salida

HashMap: {Java=8, JavaScript=1, Python=3}

En el ejemplo anterior, hemos creado un HashMap idiomas nombrados .

Aquí, hemos usado el put() método para agregar elementos al hashmap. Aprenderemos más sobre el put() más adelante en este tutorial.

Operaciones básicas en Java HashMap

El HashMap class proporciona varios métodos para realizar diferentes operaciones en hashmaps. Veremos algunas operaciones de listas de arreglos de uso común en este tutorial:

Añadir elementos
Acceder a elementos
Cambiar elementos
Eliminar elementos

1. Añadir elementos a un HashMap

Para agregar un solo elemento al hashmap, usamos el put() método del HashMap clase. Por ejemplo,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    // create a hashmap
    HashMap<String, Integer> numbers = new HashMap<>();

    System.out.println("Initial HashMap: " + numbers);
    // put() method to add elements
    numbers.put("One", 1);
    numbers.put("Two", 2);
    numbers.put("Three", 3);
    System.out.println("HashMap after put(): " + numbers);
  }
}

Salida

Initial HashMap: {}
HashMap after put(): {One=1, Two=2, Three=3}

En el ejemplo anterior, hemos creado un HashMap números con nombre . Aquí, hemos usado el put() método para agregar elementos a los números.

Note la declaración,

numbers.put("One", 1);

Aquí, estamos pasando el String valor Uno como clave y Integer valor 1 como el valor del put() método.

Lecturas recomendadas

Put() de Java HashMap
Java HashMap putAll()
Java HashMap putIfAbsent()

2. Acceder a los elementos de HashMap

Podemos usar el get() para acceder al valor del hashmap. Por ejemplo,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // get() method to get value
    String value = languages.get(1);
    System.out.println("Value at index 1: " + value);
  }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript}
Value at index 1: Java

En el ejemplo anterior, observe la expresión,

languages.get(1);

Aquí, el get() el método toma la clave como su argumento y devuelve el valor correspondiente asociado con la clave.

También podemos acceder a las teclas , valores y clave/valor pares del hashmap como vistas establecidas usando keySet() , values() y entrySet() métodos respectivamente. Por ejemplo,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {
    HashMap<Integer, String> languages = new HashMap<>();

    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // return set view of keys
    // using keySet()
    System.out.println("Keys: " + languages.keySet());

    // return set view of values
    // using values()
    System.out.println("Values: " + languages.values());

    // return set view of key/value pairs
    // using entrySet()
    System.out.println("Key/Value mappings: " + languages.entrySet());
  }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: [1, 2, 3]
Values: [Java, Python, JavaScript]
Key/Value mappings: [1=Java, 2=Python, 3=JavaScript]

En el ejemplo anterior, hemos creado un hashmap llamado languages . Aquí, estamos accediendo a las teclas , valores y clave/valor mapeos del hashmap.

Lecturas recomendadas

Java HashMap get()
Java Hashmap getOrDefault()
Conjunto de claves Java HashMap()
Valores Java HashMap()
Conjunto de entradas Java HashMap()

3. Cambiar el valor de HashMap

Podemos usar el replace() método para cambiar el valor asociado con una clave en un hashmap. Por ejemplo,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("Original HashMap: " + languages);

    // change element with key 2
    languages.replace(2, "C++");
    System.out.println("HashMap using replace(): " + languages);
  }
}

Salida

Original HashMap: {1=Java, 2=Python, 3=JavaScript}
HashMap using replace(): {1=Java, 2=C++, 3=JavaScript}

En el ejemplo anterior, hemos creado un hashmap llamado languages . Observe la expresión,

languages.replace(2, "C++");

Aquí, estamos cambiando el valor al que hace referencia la clave 2 con el nuevo valor C++ .

El HashMap class también proporciona algunas variaciones del replace() método. Para obtener más información, visite

Reemplazo de Java HashMap()
Java HashMap replaceAll()

4. Eliminar elementos de HashMap

Para eliminar elementos de un hashmap, podemos usar el método remove(). Por ejemplo,

import java.util.HashMap;

class Main {
  public static void main(String[] args) {

    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // remove element associated with key 2
    String value = languages.remove(2);
    System.out.println("Removed value: " + value);

    System.out.println("Updated HashMap: " + languages);
  }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript}
Removed value: Python
Updated HashMap: {1=Java, 3=JavaScript}

Aquí, el remove() el método toma la clave como su parámetro. Luego devuelve el valor asociado con la clave y elimina la entrada .

También podemos eliminar la entrada solo bajo ciertas condiciones. Por ejemplo,

remove(2, "C++");

Aquí, el remove() El método solo elimina la entrada si la tecla 2 está asociado con el valor C++ . Desde 2 no está asociado con C++ , no elimina la entrada.

Para obtener más información, visite Java HashMap remove().

Otros métodos de HashMap

Método	Descripción
borrar()	elimina todas las asignaciones del `HashMap`
calcular()	calcula un nuevo valor para la clave especificada
computeIfAbsent()	calcula el valor si no hay una asignación para la clave
computeIfPresent()	calcula un valor para el mapeo si la clave está presente
combinar()	combina la asignación especificada con el `HashMap`
clonar()	hace la copia del `HashMap`
contieneClave()	comprueba si la clave especificada está presente en Hashmap
contieneValor()	comprueba si `Hashmap` contiene el valor especificado
tamaño()	devuelve el número de elementos en `HashMap`
estáVacío()	comprueba si el `Hashmap` está vacío

Iterar a través de un HashMap

Para iterar a través de cada entrada del hashmap, podemos usar el bucle for-each de Java. Podemos iterar a través de claves solamente , solo valores y asignación de clave/valor . Por ejemplo,

import java.util.HashMap;
import java.util.Map.Entry;

class Main {
  public static void main(String[] args) {

    // create a HashMap
    HashMap<Integer, String> languages = new HashMap<>();
    languages.put(1, "Java");
    languages.put(2, "Python");
    languages.put(3, "JavaScript");
    System.out.println("HashMap: " + languages);

    // iterate through keys only
    System.out.print("Keys: ");
    for (Integer key : languages.keySet()) {
      System.out.print(key);
      System.out.print(", ");
    }

    // iterate through values only
    System.out.print("\nValues: ");
    for (String value : languages.values()) {
      System.out.print(value);
      System.out.print(", ");
    }
    
    // iterate through key/value entries
    System.out.print("\nEntries: ");
    for (Entry<Integer, String> entry : languages.entrySet()) {
      System.out.print(entry);
      System.out.print(", ");
    }
  }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: 1, 2, 3,
Values: Java, Python, JavaScript,        
Entries: 1=Java, 2=Python, 3=JavaScript,

Tenga en cuenta que hemos utilizado el Map.Entry en el ejemplo anterior. Es la clase anidada del Map interfaz que devuelve una vista (elementos) del mapa.

Primero necesitamos importar el java.util.Map.Entry paquete para usar esta clase.

Esta clase anidada devuelve una vista (elementos) del mapa.

Creación de HashMap a partir de otros mapas

En Java, también podemos crear un hashmap a partir de otros mapas. Por ejemplo,

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

class Main {
  public static void main(String[] args) {

    // create a treemap
    TreeMap<String, Integer> evenNumbers = new TreeMap<>();
    evenNumbers.put("Two", 2);
    evenNumbers.put("Four", 4);
    System.out.println("TreeMap: " + evenNumbers);

    // create hashmap from the treemap
    HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
    numbers.put("Three", 3);
    System.out.println("HashMap: " + numbers);
  }
}

Salida

TreeMap: {Four=4, Two=2}
HashMap: {Two=2, Three=3, Four=4}

En el ejemplo anterior, hemos creado un TreeMap llamado evenNumbers . Observe la expresión,

numbers = new HashMap<>(evenNumbers)

Aquí, estamos creando un HashMap números con nombre usando el TreeMap . Para obtener más información sobre el diagrama de árbol, visite Java TreeMap.

Nota :al crear un hashmap, podemos incluir parámetros opcionales:capacidad y factor de carga . Por ejemplo,

HashMap<K, V> numbers = new HashMap<>(8, 0.6f);

Aquí,

8 (la capacidad es 8) - Esto significa que puede almacenar 8 entradas.
0.6f (el factor de carga es 0,6):esto significa que cada vez que nuestra tabla hash se llena en un 60 %, las entradas se mueven a una nueva tabla hash del doble del tamaño de la tabla hash original.

Si no se utilizan los parámetros opcionales, la capacidad predeterminada tendrá 16 y el factor de carga predeterminado será 0,75 .

Interfaz de mapas de Java Java LinkedHashMap

Java