Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Aprende ¿Qué es Mapa? | Mapa
Estructuras de Datos en Java

book¿Qué es Mapa?

Por último, hemos pasado a estructuras de datos realmente complejas e intrigantes. Hoy hablaremos de la interfaz Map de Java. La interfaz Map forma parte del marco de trabajo Java Collections y define métodos para trabajar con datos en forma de pares clave-valor.

Veamos su definición:

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

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

main.java

main.java

copy

              
1

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

Aquí, vemos que en los paréntesis genéricos o paréntesis de diamante, se especifican dos valores:

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

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

Examinemos ahora los métodos definidos en la interfaz Map:

  • V put(K clave, V valor):
    • Asocia el valor especificado con la clave especificada en este mapa. Si el mapa contenía anteriormente una asignación para la clave, el valor anterior se sustituye.

Nota

En el caso de utilizar HashMap<>(), al insertar múltiples valores con la misma clave, se produce una colisión. Profundizaremos en el principio de funcionamiento de HashMap más adelante en esta sección.

main.java

main.java

copy

              
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(Clave objeto):
    • Devuelve el valor al que está asignada la clave especificada, o null si este mapa no contiene ninguna asignación para la clave.

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

Recuperemos el valor con la clave 2:

main.java

main.java

copy

              
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 contieneClave(Clave objeto):

    • Devuelve true si el mapa contiene una asignación para la clave especificada.

  • boolean containsValue(Valor del objeto):

    • Devuelve true si el mapa contiene una o más claves asignadas al valor especificado.

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

Veamos un ejemplo:

main.java

main.java

copy

              
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, comprobamos la presencia de una clave y la presencia de un valor en el mapa. Si se encuentran valores, los mostramos en la consola. Si no hay tales valores, mostramos mensajes indicando la ausencia de tales datos.

  • Boolean isEmpty()`:

    • Devuelve true si este mapa no contiene ninguna correspondencia clave-valor.

  • V remove(Clave objeto):

    • Elimina el mapeo para la clave especificada de este mapa si está presente y devuelve el valor anterior.

Al igual que en otras estructuras de datos, podemos eliminar elementos del mapa.

Nota

Al usar HashMap, todos los valores bajo una clave serán eliminados. Profundizaremos en esto más adelante en esta sección.

main.java

main.java

copy

              
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.

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

Empecemos por lo básico:

  • void clear():

    • Elimina todos los elementos del mapa.

  • size()`:

    • Devuelve el número de asignaciones clave-valor de este mapa.

  • void putAll(Map<? extends K, ? extends V> m):

    • Copia todos los mapeos del mapa especificado a este mapa.

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

main.java

main.java

copy

              
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í, hemos obtenido una colección de valores del mapa. Ahora, podemos transferir esta colección a un ArrayList:

main.java

main.java

copy

              
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);
    }
}

Inicializamos un ArrayList usando valores del mapa.

También hay un método que devuelve claves del mapa. Sin embargo, estas claves serán devueltas en forma de una estructura llamada Set. No vamos a profundizar en esta estructura de datos ahora; vale la pena mencionar que un Set es una estructura de datos que contiene exclusivamente valores únicos.

Veamos este método:

  • Set<K> keySet():
    • Devuelve una vista Set de las claves contenidas en este mapa.
main.java

main.java

copy

              
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 recuperar un conjunto de todas las claves del mapa.

Bueno, parece que hemos terminado con los métodos. Veamos ahora el uso del mapa, así como ejemplos prácticos:

Uso del mapa

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

Creemos un mapa donde la clave sea de tipo String, que representa el nombre del alumno, y el valor sea de tipo Integer, que representa la calificación del alumno. De esta forma, podemos asignar notas a los alumnos y recuperar fácilmente la nota de un alumno concreto utilizando la clave:

main.java

main.java

copy

              
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 tenemos la tarea de recuperar las notas de Mike y Alice, y luego compararlas. Podemos lograrlo fácilmente utilizando los métodos que hemos aprendido anteriormente. Implementemos esto en el código:

main.java

main.java

copy

              
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");
    }
}

He utilizado el operador ternario y el método compareTo() de la clase envolvente Integer. En caso de que no entiendas cómo funciona, se puede explicar de la siguiente manera:

main.java

main.java

copy

              
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");
        }
    }
}

Nota

Si lo piensas, este tipo de consultas son muy similares a las consultas SQL. Si estás familiarizado con SQL, te será mucho más fácil entender la interacción con diferentes estructuras de datos y bases de datos.

Consideremos ahora qué pasaría si se nos pidiera reunir a todos los alumnos con una nota superior a 7 (excluyendo el 7). Esto se vuelve interesante, ¡y ahora te explicaré cómo hacerlo!

Iteración a través del mapa

Iterar sobre los elementos de un Map en Java se puede hacer utilizando varios métodos proporcionados por la interfaz Map y sus implementaciones. Aquí hay varias maneras de iterar sobre un Map:

  • Iterar sobre claves (keySet()):**
    • El método keySet() devuelve un conjunto de todas las claves del Map. Puedes utilizar este conjunto para iterar sobre las claves y recuperar los valores correspondientes.
main.java

main.java

copy

              
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);
        }
    }
}
  • Iterar sobre valores (values()):**
    • El método values() devuelve una colección de todos los valores del Map. Puedes utilizar esta colección para iterar sobre los valores.
main.java

main.java

copy

              
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);
        }
    }
}
  • Iterar sobre pares clave-valor (entrySet()):**
    • El método entrySet() devuelve un conjunto de objetos Map.Entry que representan pares clave-valor. Esto permite iterar sobre los pares directamente.
main.java

main.java

copy

              
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. Inicialmente, puede parecer insanamente complejo de entender, pero no es necesario entrar en los detalles de cómo funciona, ya que la sintaxis es siempre la misma:

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

Utilizando el objeto entry, podemos acceder simultáneamente tanto a la clave como al valor en el mapa. Ahora, vamos a resolver la tarea dada anteriormente utilizando el conjunto de entradas: recuperar todos los alumnos con una nota superior a 7. Para ello, utilizaremos una comprobación a través de entry.getValue(), y cuando encontremos estudiantes adecuados, recuperaremos sus claves en una ArrayList creada previamente:

main.java

main.java

copy

              
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í, podemos iterar por el mapa y encontrar la lista deseada de alumnos que han aprobado el examen.

El conjunto de entradas es una herramienta muy útil, ya que permite varias formas de recorrer el mapa mediante un bucle, teniendo acceso tanto a la clave como al valor.

En el próximo capítulo nos adentraremos en el funcionamiento real de HashMap, que hemos utilizado tan activamente en este capítulo.

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

2. ¿Cómo se recorren todas las claves de un Map utilizando un bucle for-each?

3. ¿Para qué sirve el 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 de Java representa una colección de pares clave-valor?

Select the correct answer

question mark

¿Cómo se recorren todas las claves de un Map utilizando un bucle for-each?

Select the correct answer

question mark

¿Para qué sirve el método values() en un Map?

Select the correct answer

question mark

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

Select the correct answer

question mark

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

Select the correct answer

¿Todo estuvo claro?

¿Cómo podemos mejorarlo?

¡Gracias por tus comentarios!

Sección 3. Capítulo 1

Pregunte a AI

expand

Pregunte a AI

ChatGPT

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

Awesome!

Completion rate improved to 4

book¿Qué es Mapa?

Desliza para mostrar el menú

Por último, hemos pasado a estructuras de datos realmente complejas e intrigantes. Hoy hablaremos de la interfaz Map de Java. La interfaz Map forma parte del marco de trabajo Java Collections y define métodos para trabajar con datos en forma de pares clave-valor.

Veamos su definición:

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

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

main.java

main.java

copy

              
1

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

Aquí, vemos que en los paréntesis genéricos o paréntesis de diamante, se especifican dos valores:

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

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

Examinemos ahora los métodos definidos en la interfaz Map:

  • V put(K clave, V valor):
    • Asocia el valor especificado con la clave especificada en este mapa. Si el mapa contenía anteriormente una asignación para la clave, el valor anterior se sustituye.

Nota

En el caso de utilizar HashMap<>(), al insertar múltiples valores con la misma clave, se produce una colisión. Profundizaremos en el principio de funcionamiento de HashMap más adelante en esta sección.

main.java

main.java

copy

              
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(Clave objeto):
    • Devuelve el valor al que está asignada la clave especificada, o null si este mapa no contiene ninguna asignación para la clave.

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

Recuperemos el valor con la clave 2:

main.java

main.java

copy

              
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 contieneClave(Clave objeto):

    • Devuelve true si el mapa contiene una asignación para la clave especificada.

  • boolean containsValue(Valor del objeto):

    • Devuelve true si el mapa contiene una o más claves asignadas al valor especificado.

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

Veamos un ejemplo:

main.java

main.java

copy

              
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, comprobamos la presencia de una clave y la presencia de un valor en el mapa. Si se encuentran valores, los mostramos en la consola. Si no hay tales valores, mostramos mensajes indicando la ausencia de tales datos.

  • Boolean isEmpty()`:

    • Devuelve true si este mapa no contiene ninguna correspondencia clave-valor.

  • V remove(Clave objeto):

    • Elimina el mapeo para la clave especificada de este mapa si está presente y devuelve el valor anterior.

Al igual que en otras estructuras de datos, podemos eliminar elementos del mapa.

Nota

Al usar HashMap, todos los valores bajo una clave serán eliminados. Profundizaremos en esto más adelante en esta sección.

main.java

main.java

copy

              
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.

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

Empecemos por lo básico:

  • void clear():

    • Elimina todos los elementos del mapa.

  • size()`:

    • Devuelve el número de asignaciones clave-valor de este mapa.

  • void putAll(Map<? extends K, ? extends V> m):

    • Copia todos los mapeos del mapa especificado a este mapa.

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

main.java

main.java

copy

              
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í, hemos obtenido una colección de valores del mapa. Ahora, podemos transferir esta colección a un ArrayList:

main.java

main.java

copy

              
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);
    }
}

Inicializamos un ArrayList usando valores del mapa.

También hay un método que devuelve claves del mapa. Sin embargo, estas claves serán devueltas en forma de una estructura llamada Set. No vamos a profundizar en esta estructura de datos ahora; vale la pena mencionar que un Set es una estructura de datos que contiene exclusivamente valores únicos.

Veamos este método:

  • Set<K> keySet():
    • Devuelve una vista Set de las claves contenidas en este mapa.
main.java

main.java

copy

              
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 recuperar un conjunto de todas las claves del mapa.

Bueno, parece que hemos terminado con los métodos. Veamos ahora el uso del mapa, así como ejemplos prácticos:

Uso del mapa

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

Creemos un mapa donde la clave sea de tipo String, que representa el nombre del alumno, y el valor sea de tipo Integer, que representa la calificación del alumno. De esta forma, podemos asignar notas a los alumnos y recuperar fácilmente la nota de un alumno concreto utilizando la clave:

main.java

main.java

copy

              
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 tenemos la tarea de recuperar las notas de Mike y Alice, y luego compararlas. Podemos lograrlo fácilmente utilizando los métodos que hemos aprendido anteriormente. Implementemos esto en el código:

main.java

main.java

copy

              
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");
    }
}

He utilizado el operador ternario y el método compareTo() de la clase envolvente Integer. En caso de que no entiendas cómo funciona, se puede explicar de la siguiente manera:

main.java

main.java

copy

              
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");
        }
    }
}

Nota

Si lo piensas, este tipo de consultas son muy similares a las consultas SQL. Si estás familiarizado con SQL, te será mucho más fácil entender la interacción con diferentes estructuras de datos y bases de datos.

Consideremos ahora qué pasaría si se nos pidiera reunir a todos los alumnos con una nota superior a 7 (excluyendo el 7). Esto se vuelve interesante, ¡y ahora te explicaré cómo hacerlo!

Iteración a través del mapa

Iterar sobre los elementos de un Map en Java se puede hacer utilizando varios métodos proporcionados por la interfaz Map y sus implementaciones. Aquí hay varias maneras de iterar sobre un Map:

  • Iterar sobre claves (keySet()):**
    • El método keySet() devuelve un conjunto de todas las claves del Map. Puedes utilizar este conjunto para iterar sobre las claves y recuperar los valores correspondientes.
main.java

main.java

copy

              
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);
        }
    }
}
  • Iterar sobre valores (values()):**
    • El método values() devuelve una colección de todos los valores del Map. Puedes utilizar esta colección para iterar sobre los valores.
main.java

main.java

copy

              
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);
        }
    }
}
  • Iterar sobre pares clave-valor (entrySet()):**
    • El método entrySet() devuelve un conjunto de objetos Map.Entry que representan pares clave-valor. Esto permite iterar sobre los pares directamente.
main.java

main.java

copy

              
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. Inicialmente, puede parecer insanamente complejo de entender, pero no es necesario entrar en los detalles de cómo funciona, ya que la sintaxis es siempre la misma:

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

Utilizando el objeto entry, podemos acceder simultáneamente tanto a la clave como al valor en el mapa. Ahora, vamos a resolver la tarea dada anteriormente utilizando el conjunto de entradas: recuperar todos los alumnos con una nota superior a 7. Para ello, utilizaremos una comprobación a través de entry.getValue(), y cuando encontremos estudiantes adecuados, recuperaremos sus claves en una ArrayList creada previamente:

main.java

main.java

copy

              
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í, podemos iterar por el mapa y encontrar la lista deseada de alumnos que han aprobado el examen.

El conjunto de entradas es una herramienta muy útil, ya que permite varias formas de recorrer el mapa mediante un bucle, teniendo acceso tanto a la clave como al valor.

En el próximo capítulo nos adentraremos en el funcionamiento real de HashMap, que hemos utilizado tan activamente en este capítulo.

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

2. ¿Cómo se recorren todas las claves de un Map utilizando un bucle for-each?

3. ¿Para qué sirve el 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 de Java representa una colección de pares clave-valor?

Select the correct answer

question mark

¿Cómo se recorren todas las claves de un Map utilizando un bucle for-each?

Select the correct answer

question mark

¿Para qué sirve el método values() en un Map?

Select the correct answer

question mark

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

Select the correct answer

question mark

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

Select the correct answer

¿Todo estuvo claro?

¿Cómo podemos mejorarlo?

¡Gracias por tus comentarios!

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