Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Aprende ¿Qué Es un Map? | Sección
Estructuras de Datos Fundamentales en Java

¿Qué Es un Map?

Desliza para mostrar el menú

Analizaremos la interfaz Map en Java. La interfaz Map forma parte del framework de colecciones de Java y define métodos para trabajar con datos en forma de pares clave-valor.

Veamos la definición:

La implementación principal de esta estructura de datos en Java es HashMap, que implementa la interfaz Map. Examinemos los métodos principales y los principios de funcionamiento de esta implementación.

Comenzaremos con la declaración y los métodos:

Main.java

Main.java


              
1

            
Map<K, V> map = new HashMap<>();

Aquí, se observa que en los genéricos o corchetes angulares, se especifican dos valores:

  • El valor K corresponde al tipo de dato de la clave;
  • El valor V corresponde al tipo de dato del valor.

Así, al declarar esta estructura de datos, se indican los tipos de datos de nuestros valores clave-valor.

Ahora, examinemos los métodos definidos en la interfaz Map.

Métodos

V put(K key, V value): asocia el valor especificado con la clave especificada en este Map. Si el Map contenía previamente una asignación para la clave, el valor anterior es reemplazado.

Main.java

Main.java


              
1234567891011121314

            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println(map);
    }
}

V get(Object key): devuelve el valor al que está asociada la clave especificada, o null si este Map no contiene una asociación para la clave.

Aquí es donde se especifica la clave para obtener el valor correspondiente.

Vamos a obtener el valor con la clave 2:

Main.java

Main.java


              
12345678910111213141516

            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String value = map.get(2);
        System.out.println("Value: " + value);
    }
}

  • boolean containsKey(Object key): devuelve true si el Map contiene una asociación para la clave especificada;

  • boolean containsValue(Object value): devuelve true si el Map contiene una o más claves asociadas al valor especificado.

Estos dos métodos están claramente relacionados, y ayudan a determinar si el Map especificado contiene las claves o valores deseados. Estos métodos son convenientes para usar como condiciones ya que devuelven valores boolean.

Veamos un ejemplo:

Main.java

Main.java


              
12345678910111213141516171819202122232425

            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        if (map.containsKey(2)) {
            System.out.println("Value with key 2: " + map.get(2));
        } else {
            System.out.println("There is no value with key 2!");
        }

        if (map.containsValue("Four")) {
            System.out.println(map.get(4));
        } else {
            System.out.println("There is no key with value \"Four\"!");
        }
    }
}

En el ejemplo anterior, se verifica la presencia de una clave y la presencia de un valor en el Map. Si se encuentran valores, se muestran en la consola. Si no existen dichos valores, se muestran mensajes que indican la ausencia de dichos datos.

  • boolean isEmpty(): devuelve true si este Map no contiene asociaciones clave-valor;

  • V remove(Object key): elimina la asociación para la clave especificada de este Map si está presente y devuelve el valor anterior.

Al igual que en otras estructuras de datos, es posible eliminar elementos del Map.

Main.java

Main.java


              
12345678910111213141516

            
package com.example;

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

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        String removedElement = map.remove(3);
        System.out.println("Removed value: " + removedElement + ".\nMap after the removal operation: " + map);
    }
}

Así, podemos eliminar elementos por clave.

Métodos básicos para gestionar mapas

A continuación, se presentan métodos con los que ya está familiarizado, los cuales enumeraré sin ejemplos. Pero también quedan métodos interesantes.

Comencemos con lo básico:

  • void clear(): elimina todos los elementos del Map;

  • int size(): devuelve el número de asociaciones clave-valor en este Map;

  • void putAll(Map<? extends K, ? extends V> m): copia todas las asociaciones del Map especificado a este Map.

Ahora, pasemos a los métodos que devuelven una colección con valores (o claves) del Map. En otras palabras, obtenemos de la estructura de datos una estructura clave-valor que almacena solo valores (o claves). Por ejemplo, ArrayList<>.

Main.java

Main.java


              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> list;
        list = map.values();
        System.out.println("Values" + list);
    }
}

Aquí, obtuvimos una colección de valores del Map. Ahora, podemos transferir esta colección a un ArrayList:

Main.java

Main.java


              
123456789101112131415161718

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Collection<String> collection;
        collection = map.values();
        System.out.println("Values" + collection);
        List<String> arrayList = new ArrayList<>(collection);
        System.out.println("ArrayList: " + arrayList);
    }
}

Se inicializó un ArrayList utilizando valores del Map.

También existe un método que devuelve las claves del Map. Sin embargo, estas claves se devolverán en forma de una estructura llamada Set. No profundizaremos en esta estructura de datos ahora; cabe mencionar que un Set es una estructura de datos que contiene exclusivamente valores únicos.

Observemos este método:

Set<K> keySet(): devuelve una vista Set de las claves contenidas en este Map.

Main.java

Main.java


              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");
        map.put(3, "Three");
        System.out.println("Map: " + map);
        Set<Integer> keys;
        keys = map.keySet();
        System.out.println("Keys: " + keys);
    }
}

Así, también podemos obtener un conjunto de todas las claves del Map.

Bien, parece que hemos terminado con los métodos. Ahora veamos el uso de Map, así como algunos ejemplos prácticos:

Uso de Map

Una estructura como clave-valor tiene muchas aplicaciones prácticas. Consideremos la más simple de estas estructuras: un sistema de calificaciones estudiantiles.

Creemos un Map donde la clave sea de tipo String, representando el nombre del estudiante, y el valor sea de tipo Integer, representando la calificación del estudiante. De esta manera, se pueden asignar calificaciones a los estudiantes y recuperar fácilmente la calificación de un estudiante específico usando la clave:

Main.java

Main.java


              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
    }
}

Ahora, imaginemos que se nos asigna la tarea de recuperar las calificaciones de Mike y Alice, y luego compararlas. Puedes lograr esto fácilmente utilizando los métodos que has aprendido anteriormente. Implementémoslo en el código:

Main.java

Main.java


              
123456789101112131415161718192021

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        System.out.println(mikeGrade.compareTo(aliceGrade) == -1 ? "Alice's grade is higher": "Mike's grade is higher");
    }
}

Se utilizó el operador ternario y el método compareTo() de la clase contenedora Integer. En caso de que no comprendas cómo funciona, se puede explicar de la siguiente manera:

Main.java

Main.java


              
12345678910111213141516171819202122232425

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);

        Integer mikeGrade = studentsGrades.get("Mike");
        Integer aliceGrade = studentsGrades.get("Alice");

        if (mikeGrade.compareTo(aliceGrade) == -1) {
            System.out.println("Alice's grade is higher");
        } else {
            System.out.println("Mike's grade is higher");
        }
    }
}

Ahora, consideremos qué sucede si se nos pide reunir a todos los estudiantes con una calificación superior a 7 (excluyendo 7). Esto se vuelve interesante, y ahora te explicaré cómo hacerlo.

Iteración a través del Map

La iteración sobre los elementos en un Map en Java puede realizarse utilizando varios métodos proporcionados por la interfaz Map y sus implementaciones. A continuación se presentan varias formas de iterar sobre un Map:

Iteración sobre claves (keySet()): el método keySet() devuelve un conjunto de todas las claves en el Map. Puede utilizar este conjunto para iterar sobre las claves y recuperar los valores correspondientes.

Main.java

Main.java


              
12345678910111213141516

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Iteración sobre valores (values()): el método values() devuelve una colección de todos los valores en el Map. Esta colección puede utilizarse para recorrer los valores.

Main.java

Main.java


              
123456789101112131415

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Integer value : map.values()) {
            System.out.println("Value: " + value);
        }
    }
}

Iteración sobre pares clave-valor (entrySet()): el método entrySet() devuelve un conjunto de objetos Map.Entry que representan pares clave-valor. Esto permite iterar directamente sobre los pares.

Main.java

Main.java


              
1234567891011121314151617

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Key1", 1);
        map.put("Key2", 2);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + value);
        }
    }
}

Profundicemos un poco más en esto. Al principio, puede parecer extremadamente complejo de entender, pero no es necesario entrar en los detalles de cómo funciona, ya que la sintaxis siempre es la misma.

Map.Entry<K, V> entry : map.entrySet()

Utilizando el objeto entry, es posible acceder tanto a la clave como al valor en el Map de manera simultánea. Ahora, resolvamos la tarea mencionada anteriormente usando el entry set: recuperar todos los estudiantes con una calificación mayor que 7. Para ello, se utilizará una comprobación mediante entry.getValue(), y cuando se encuentren estudiantes adecuados, se recuperarán sus claves en un ArrayList previamente creado:

Main.java

Main.java


              
1234567891011121314151617181920212223242526

            
package com.example;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> studentsGrades = new HashMap<>();
        studentsGrades.put("Bob", 9);
        studentsGrades.put("Alice", 8);
        studentsGrades.put("Mike", 5);
        studentsGrades.put("John", 10);
        studentsGrades.put("Martin", 7);
        studentsGrades.put("Peter", 5);
        System.out.println("Student's grades: " + studentsGrades);
        
        List<String> studentsWithGradeHigherThanSeven = new ArrayList<>();
        
        for (Map.Entry<String, Integer> entry : studentsGrades.entrySet()) {
            if (entry.getValue() > 7) {
                studentsWithGradeHigherThanSeven.add(entry.getKey());
            }
        
        }
        System.out.println(studentsWithGradeHigherThanSeven);
    }
}

Así, puedes iterar a través del Map y encontrar la lista deseada de estudiantes que aprobaron el examen.

El conjunto de entradas es una herramienta muy útil ya que permite diversas formas de iterar a través del Map usando un bucle, teniendo acceso tanto a la clave como al valor.

En el próximo capítulo, profundizaremos en cómo funciona realmente HashMap, que hemos utilizado tan activamente en este capítulo.

1. ¿Qué interfaz en Java representa una colección de pares clave-valor?

2. ¿Cómo se itera a través de todas las claves en un Map utilizando un bucle for-each?

3. ¿Cuál es el propósito del método values() en un Map?

4. ¿Qué método se utiliza para comprobar si una clave específica está presente en un Map?

5. ¿Qué método se utiliza para eliminar un par clave-valor de un Map en Java?

question mark

¿Qué interfaz en Java representa una colección de pares clave-valor?

Selecciona la respuesta correcta

question mark

¿Cómo se itera a través de todas las claves en un Map utilizando un bucle for-each?

Selecciona la respuesta correcta

question mark

¿Cuál es el propósito del método values() en un Map?

Selecciona la respuesta correcta

question mark

¿Qué método se utiliza para comprobar si una clave específica está presente en un Map?

Selecciona la respuesta correcta

question mark

¿Qué método se utiliza para eliminar un par clave-valor de un Map en Java?

Selecciona la respuesta correcta

¿Todo estuvo claro?

¿Cómo podemos mejorarlo?

¡Gracias por tus comentarios!

Sección 1. Capítulo 13

Pregunte a AI

expand

Pregunte a AI

ChatGPT

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Sección 1. Capítulo 13
some-alt