← Volver a los ejercicios

Un Map recorrido como colección de parejas

Buscar por la llave es una cara del Map. La otra es que sus entradas se pueden recorrer: cada elemento es la pareja de una llave con su valor, y de ahí que el mapa acepte toList, map, filter y expresiones for con la misma escritura de una lista. Lo que hay que mirar de cerca es cómo sale el resultado, porque no siempre vuelve en la misma colección en que entró: pedirle las llaves y pedirle los valores devuelve dos cosas distintas, y transformar las parejas devuelve otro mapa. Prediga primero y después decida entre opciones; todo valor que la página da por correcto salió de correr el código con Scala 2.13.11.

1. El archivo

Las cuatro primeras líneas que imprimen trabajan sobre el mapa de dos entradas. La última agrupa cinco palabras por su primera letra y cuenta cuántas quedaron en cada grupo.

2. Prediga las cuatro líneas del mapa

Los espacios, las mayúsculas y las comillas de más no cambian la respuesta. El nombre de la colección que sale sí: es parte de lo que se pregunta.

líneasu respuestaimprime

3. Cada elemento es una pareja

De eso sale todo lo demás: lo que recibe la función de map, en qué colección cae el resultado y por qué las llaves y los valores no se piden de la misma forma.

4. Agrupar y contar

1val palabras = List("sol", "sal", "mar", "luna", "mes")
2println(palabras.groupBy(_.head).map { case (c, ps) => (c, ps.length) })

Dos pasos en una línea: agrupar las palabras por su primera letra y cambiar cada grupo por cuántas palabras tiene. El segundo paso es un map sobre un mapa, con el mismo case que desarma la pareja.

5. Las cinco líneas, en claro

La líneaLo que imprimió
capital.toListList((USA,Washington), (COLOMBIA,Bogota))
capital.map { case (k, v) => (v, k) }Map(Washington -> USA, Bogota -> COLOMBIA)
capital.keysSet(USA, COLOMBIA)
capital.valuesIterable(Washington, Bogota)
palabras.groupBy(_.head).map { case (c, ps) => (c, ps.length) }HashMap(s -> 2, m -> 2, l -> 1)

capital.toList muestra de qué está hecho un mapa: dos elementos, y cada uno es la pareja de una entrada, (USA,Washington). La flecha es la forma de escribir esa pareja al construir el mapa; recorrida, la pareja sale con sus dos componentes entre paréntesis.

Por eso map se escribe sobre un mapa igual que sobre una lista, y el case (k, v) es lo que le pone nombre a las dos partes del elemento que llegó. La función de capital.map { case (k, v) => (v, k) } devuelve una pareja por cada entrada, con el valor primero, y con parejas hay con qué armar entradas: el resultado vuelve a ser un mapa, Map(Washington -> USA, Bogota -> COLOMBIA). Cada pareja se invierte dentro de su propia entrada, de modo que Washington sigue junto a USA.

Pedir las llaves y pedir los valores devuelve dos colecciones distintas, y eso se lee en lo impreso: Set(USA, COLOMBIA) frente a Iterable(Washington, Bogota). Las llaves de un mapa no se repiten, así que forman un conjunto. Dos entradas distintas sí pueden compartir el valor, de modo que los valores llegan en la colección más general, la que solo promete que se puede recorrer.

La última línea compone las dos ideas. groupBy(_.head) reparte las cinco palabras y entrega un mapa de cada inicial a las palabras que empiezan con ella; el map que sigue lo recorre como colección de parejas y cambia cada grupo por su largo. Quedan tres entradas, con sol y sal en la s, mar y mes en la m y luna en la l: HashMap(s -> 2, m -> 2, l -> 1). El nombre impreso es la implementación que sostiene ese mapa y el orden de las entradas no es el de la lista de partida, dos cosas que un mapa no promete. Lo que promete es la asociación entre cada llave y su valor, y que se puede recorrer pareja por pareja.