Interfaz de mapa en Java

La interfaz de mapa está presente en el paquete java.util y representa un mapeo entre una clave y un valor. La interfaz Mapa no es un subtipo de la interfaz Colección . Por lo tanto, se comporta un poco diferente al resto de los tipos de colección. Un mapa contiene claves únicas.

Geeks, la lluvia de ideas debería haber sido por qué y cuándo usar Maps.

Los mapas son perfectos para usar en el mapeo de asociación de clave-valor, como los diccionarios. Los mapas se utilizan para realizar búsquedas por claves o cuando alguien quiere recuperar y actualizar elementos por claves. Algunos escenarios comunes son los siguientes: 

• Un mapa de códigos de error y sus descripciones.
• Un mapa de códigos postales y ciudades.
• Un mapa de gerentes y empleados. Cada gerente (clave) está asociado con una lista de empleados (valor) que administra.
• Un mapa de clases y estudiantes. Cada clase (clave) está asociada a una lista de alumnos (valor).

Creación de objetos de mapa

Dado que Map es una interfaz , no se pueden crear objetos del tipo map. Siempre necesitamos una clase que amplíe este mapa para crear un objeto. Y también, después de la introducción de Generics en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en el Mapa. 

Sintaxis: definición del mapa con seguridad de tipos

Map hm = new HashMap(); 
// Obj is the type of the object to be stored in Map

Características de una interfaz de mapa

1. Un mapa no puede contener claves duplicadas y cada clave puede asignarse a un valor como máximo. Algunas implementaciones permiten claves nulas y valores nulos como HashMap y LinkedHashMap , pero a algunas no les gusta TreeMap .
2. El orden de un mapa depende de las implementaciones específicas. Por ejemplo, TreeMap y LinkedHashMap tienen órdenes predecibles, mientras que HashMap no.
3. Hay dos interfaces para implementar Map en Java. Son Map y SortedMap , y tres clases: HashMap, TreeMap y LinkedHashMap.

Métodos en la interfaz del mapa

 Ejemplo:

// Java Program to Demonstrate
// Working of Map interface
  
// Importing required classes
import java.util.*;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String args[])
    {
        // Creating an empty HashMap
        Map<String, Integer> hm
            = new HashMap<String, Integer>();
  
        // Inserting pairs in above Map
        // using put() method
        hm.put("a", new Integer(100));
        hm.put("b", new Integer(200));
        hm.put("c", new Integer(300));
        hm.put("d", new Integer(400));
  
        // Traversing through Map using for-each loop
        for (Map.Entry<String, Integer> me :
             hm.entrySet()) {
  
            // Printing keys
            System.out.print(me.getKey() + ":");
            System.out.println(me.getValue());
        }
    }
}

a:100
b:200
c:300
d:400

Las clases que implementan la interfaz Map se representan en los siguientes medios y se describen más adelante de la siguiente manera:

Clase 1: HashMap 

HashMap es parte de la colección de Java desde Java 1.2. Proporciona la implementación básica de la interfaz Map de Java. Almacena los datos en pares (Clave, Valor). Para acceder a un valor se debe conocer su clave. Esta clase utiliza una técnica llamada Hashing . Hashing es una técnica de convertir una string grande en una string pequeña que representa la misma string. Un valor más corto ayuda en la indexación y búsquedas más rápidas. Veamos cómo crear un objeto de mapa usando esta clase.

Ejemplo 

// Java Program to illustrate the Hashmap Class
  
// Importing required classes
import java.util.*;
  
// Main class
public class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating an empty HashMap
        Map<String, Integer> map = new HashMap<>();
  
        // Inserting entries in the Map
        // using put() method
        map.put("vishal", 10);
        map.put("sachin", 30);
        map.put("vaibhav", 20);
  
        // Iterating over Map
        for (Map.Entry<String, Integer> e : map.entrySet())
  
            // Printing key-value pairs
            System.out.println(e.getKey() + " "
                               + e.getValue());
    }
}

vaibhav 20
vishal 10
sachin 30

Clase 2: LinkedHashMap

LinkedHashMap es como HashMap con la característica adicional de mantener un orden de elementos insertados en él. HashMap proporcionó la ventaja de una inserción, búsqueda y eliminación rápidas, pero nunca mantuvo el seguimiento y el orden de inserción que proporciona LinkedHashMap donde se puede acceder a los elementos en su orden de inserción. Veamos cómo crear un objeto de mapa usando esta clase.

Ejemplo  

// Java Program to Illustrate the LinkedHashmap Class
  
// Importing required classes
import java.util.*;
  
// Main class
public class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating an empty LinkedHashMap
        Map<String, Integer> map = new LinkedHashMap<>();
  
        // Inserting pair entries in above Map
        // using put() method
        map.put("vishal", 10);
        map.put("sachin", 30);
        map.put("vaibhav", 20);
  
        // Iterating over Map
        for (Map.Entry<String, Integer> e : map.entrySet())
  
            // Printing key-value pairs
            System.out.println(e.getKey() + " "
                               + e.getValue());
    }
}

vishal 10
sachin 30
vaibhav 20

Clase 3: Mapa de árbol

TreeMap en Java se utiliza para implementar la interfaz Map y NavigableMap junto con la clase abstracta. El mapa se ordena según el orden natural de sus claves, o mediante un comparador proporcionado en el momento de la creación del mapa, según el constructor que se utilice. Esto demuestra ser una forma eficiente de ordenar y almacenar los pares clave-valor. El orden de almacenamiento mantenido por el mapa de árbol debe ser consistente con iguales al igual que cualquier otro mapa ordenado, independientemente de los comparadores explícitos. Veamos cómo crear un objeto de mapa usando esta clase.

Ejemplo  

// Java Program to Illustrate TreeMap Class
  
// Importing required classes
import java.util.*;
  
// Main class
public class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating an empty TreeMap
        Map<String, Integer> map = new TreeMap<>();
  
        // Inserting custom elements in the Map
        // using put() method
        map.put("vishal", 10);
        map.put("sachin", 30);
        map.put("vaibhav", 20);
  
        // Iterating over Map using for each loop
        for (Map.Entry<String, Integer> e : map.entrySet())
  
            // Printing key-value pairs
            System.out.println(e.getKey() + " "
                               + e.getValue());
    }
}

sachin 30
vaibhav 20
vishal 10

Realización de varias operaciones utilizando la interfaz de mapa y la clase HashMap

Dado que Map es una interfaz, solo se puede usar con una clase que implemente esta interfaz. Ahora, veamos cómo realizar algunas operaciones de uso frecuente en un mapa utilizando la clase HashMap ampliamente utilizada . Y también, tras la introducción de Generics en Java 1.5, es posible restringir el tipo de objeto que se puede almacenar en el mapa. 

Operación 1: Adición de 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 que sea más eficiente.

Ejemplo 

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Default Initialization of a
        // Map
        Map<Integer, String> hm1 = new HashMap<>();
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm2
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(1, "Geeks");
        hm1.put(2, "For");
        hm1.put(3, "Geeks");
  
        hm2.put(new Integer(1), "Geeks");
        hm2.put(new Integer(2), "For");
        hm2.put(new Integer(3), "Geeks");
  
        System.out.println(hm1);
        System.out.println(hm2);
    }
}

{1=Geeks, 2=For, 3=Geeks}
{1=Geeks, 2=For, 3=Geeks}

Operación 2: Cambio de elemento

Después 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 están indexados usando las claves, el valor de la clave se puede cambiar simplemente insertando el valor actualizado de la clave que deseamos cambiar. 

Ejemplo 

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "Geeks");
        hm1.put(new Integer(3), "Geeks");
  
        System.out.println("Initial Map " + hm1);
  
        hm1.put(new Integer(2), "For");
  
        System.out.println("Updated Map " + hm1);
    }
}

Initial Map {1=Geeks, 2=Geeks, 3=Geeks}
Updated Map {1=Geeks, 2=For, 3=Geeks}

Operación 3: Eliminación de elementos

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.

Ejemplo  

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
  
    public static void main(String args[])
    {
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "For");
        hm1.put(new Integer(3), "Geeks");
        hm1.put(new Integer(4), "For");
  
        // Initial Map
        System.out.println(hm1);
  
        hm1.remove(new Integer(4));
  
        // Final Map
        System.out.println(hm1);
    }
}

{1=Geeks, 2=For, 3=Geeks, 4=For}
{1=Geeks, 2=For, 3=Geeks}

Operación 4: Iterando a través del Mapa

Hay varias formas de iterar a través del mapa. La forma más famosa es usar un ciclo for-each y obtener las claves. El valor de la clave se encuentra utilizando el método getValue().

Ejemplo  

// Java program to demonstrate
// the working of Map interface
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
  
        // Initialization of a Map
        // using Generics
        Map<Integer, String> hm1
            = new HashMap<Integer, String>();
  
        // Inserting the Elements
        hm1.put(new Integer(1), "Geeks");
        hm1.put(new Integer(2), "For");
        hm1.put(new Integer(3), "Geeks");
  
        for (Map.Entry mapElement : hm1.entrySet()) {
            int key
                = (int)mapElement.getKey();
  
            // Finding the value
            String value
                = (String)mapElement.getValue();
  
            System.out.println(key + " : "
                               + value);
        }
    }
}

1 : Geeks
2 : For
3 : Geeks