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.
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.
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ínea | su respuesta | imprime |
|---|
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.
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.
| La línea | Lo que imprimió |
|---|---|
capital.toList | List((USA,Washington), (COLOMBIA,Bogota)) |
capital.map { case (k, v) => (v, k) } | Map(Washington -> USA, Bogota -> COLOMBIA) |
capital.keys | Set(USA, COLOMBIA) |
capital.values | Iterable(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.