in

HashMap en Java con ejemplos

gfg 200x200 min

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. Almacena los datos en pares (clave, valor) y puede acceder a ellos mediante un índice de otro tipo (por ejemplo, un entero). Un objeto se utiliza como clave (índice) para otro objeto (valor). Si intenta insertar la clave duplicada, reemplazará el elemento de la clave correspondiente.

HashMap es similar a HashTable, 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 garantiza el orden del mapa. Para utilizar esta clase y sus métodos, debe importar java.util.HashMap paquete o su superclase.

Java

import java.util.HashMap;

public class GFG {

    

    public static void main(String[] args)

    {

        

        

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

        

        

        map.put("vishal", 10);

        map.put("sachin", 30);

        map.put("vaibhav", 20);

        

        System.out.println("Size of map is:- "

                           + map.size());

        

        System.out.println(map);

        

        

        

        if (map.containsKey("vishal")) {

            

            Integer a = map.get("vishal");

            

            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

La jerarquía de HashMap es la siguiente:

Jerarquía de HashMap en Java

Sintaxis: Declaración

public class HashMap<K,V> extends AbstractMap<K,V>
                          implements Map<K,V>, Cloneable, Serializable

Parámetros: Toma dos parámetros, a saber, los siguientes:

  • El tipo de claves mantenidas por este mapa
  • El tipo de valores mapeados

Implementos HashMap Serializable, Clonable, Map interfaces. HashMap se extiende Mapa abstracto clase. Las subclases directas son LinkedHashMap, PrinterStateReasons.

Los constructores en HashMap son los siguientes:

HashMap proporciona 4 constructores y el modificador de acceso de cada uno es público, que se enumeran a continuación:

  1. HashMap ()
  2. HashMap (int initialCapacity)
  3. HashMap (int initialCapacity, float loadFactor)
  4. HashMap (mapa del mapa)

Ahora discutimos los constructores anteriores uno por uno junto con la implementación de los mismos con la ayuda de programas Java limpios.

Constructor 1: HashMap ()

Es el constructor predeterminado que crea una instancia de HashMap con una capacidad inicial de 16 y un factor de carga de 0,75.

Sintaxis:

HashMap<K, V> hm = new HashMap<K, V>();

Ejemplo

Java

import java.io.*;

import java.util.*;

class GFG {

    

    public static void main(String args[])

    {

        

        

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

        

        HashMap<Integer, String> hm2

            = new HashMap<Integer, String>();

        

        

        hm1.put(1, "one");

        hm1.put(2, "two");

        hm1.put(3, "three");

        hm2.put(4, "four");

        hm2.put(5, "five");

        hm2.put(6, "six");

        

        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 : {4=four, 5=five, 6=six}

Constructor 2: HashMap (int initialCapacity)

Crea una instancia de HashMap con una capacidad inicial especificada y factor de carga de 0,75.

Sintaxis:

HashMap<K, V> hm = new HashMap<K, V>(int initialCapacity);

Ejemplo

Java

import java.io.*;

import java.util.*;

class AddElementsToHashMap {

    

    public static void main(String args[])

    {

        

        

        HashMap<Integer, String> hm1 = new HashMap<>(10);

        

        HashMap<Integer, String> hm2

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

        

        

        

        hm1.put(1, "one");

        hm1.put(2, "two");

        hm1.put(3, "three");

        

        hm2.put(4, "four");

        hm2.put(5, "five");

        hm2.put(6, "six");

        

        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 : {4=four, 5=five, 6=six}

Constructor 3: HashMap (int initialCapacity, float loadFactor)

Crea una instancia de HashMap con una capacidad inicial especificada y un factor de carga especificado.

Sintaxis:

HashMap<K, V> hm = new HashMap<K, V>(int initialCapacity, int  loadFactor);

Ejemplo

Java

import java.io.*;

import java.util.*;

class GFG {

    

    public static void main(String args[])

    {

        

        HashMap<Integer, String> hm1

            = new HashMap<>(5, 0.75f);

        

        HashMap<Integer, String> hm2

            = new HashMap<Integer, String>(3, 0.5f);

        

        

        hm1.put(1, "one");

        hm1.put(2, "two");

        hm1.put(3, "three");

        hm2.put(4, "four");

        hm2.put(5, "five");

        hm2.put(6, "six");

        

        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 : {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 = new HashMap (mapa del mapa);

Java

import java.io.*;

import java.util.*;

class AddElementsToHashMap {

    public static void main(String args[])

    {

        

        

        Map<Integer, String> hm1 = new HashMap<>();

        

        hm1.put(1, "one");

        hm1.put(2, "two");

        hm1.put(3, "three");

        

        

        HashMap<Integer, String> hm2

            = new HashMap<Integer, String>(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}

Realización de varias operaciones en HashMap

1. Agregar elementos: Para agregar un elemento al mapa, podemos usar el método put (). Sin embargo, el orden de inserción no se conserva en el 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

import java.io.*;

import java.util.*;

class AddElementsToHashMap {

    public static void main(String args[])

    {

        

        

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

        

        

        HashMap<Integer, String> hm2

            = new HashMap<Integer, String>();

        

        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. Elementos cambiantes: Luego de agregar los elementos si deseamos cambiar el elemento, se puede hacer agregando nuevamente el elemento con el método put (). Dado que los elementos en el mapa se indexan usando las claves, el valor de la clave se puede cambiar simplemente insertando el valor actualizado para la clave que deseamos cambiar.

Java

import java.io.*;

import java.util.*;

class ChangeElementsOfHashMap {

    public static void main(String args[])

    {

        

        HashMap<Integer, String> hm

            = new HashMap<Integer, String>();

        

        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. Quitar elemento: Para eliminar un elemento del mapa, podemos usar el método remove (). 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

import java.io.*;

import java.util.*;

class RemoveElementsOfHashMap{

    public static void main(String args[])

    {

        

        Map<Integer, String> hm

            = new HashMap<Integer, String>();

        

        hm.put(1, "Geeks");

        hm.put(2, "For");

        hm.put(3, "Geeks");

        hm.put(4, "For");

        

        System.out.println("Mappings of HashMap are : "

                           + hm);

        

        

        hm.remove(4);

        

        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 HashMap

Podemos usar la interfaz Iterator para atravesar cualquier estructura del marco de la colección. Dado que los iteradores funcionan con un tipo de datos, usamos Entry ,? > para resolver los dos tipos separados en un formato compatible. Luego, usando el método next () imprimimos las entradas de HashMap.

Java

import java.util.HashMap;

import java.util.Map;

public class TraversalTheHashMap {

    public static void main(String[] args)

    {

        

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

        

        map.put("vishal", 10);

        map.put("sachin", 30);

        map.put("vaibhav", 20);

        

        

        for (Map.Entry<String, Integer> e : map.entrySet())

            System.out.println("Key: " + e.getKey()

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

apple touch icon@2

serialización: ¿cómo puedo mostrar un objeto JavaScript?

edit

Sesgo vs estereotipo: diferencia y comparación