Maps

consejo de nuevo, puedes correr el programa con shift+F10

Mapas
Los mapas asocian claves con valores. Las claves deben ser únicas, pero los valores asociados no. De este modo, cada valor puede ser usado para identificar de manera única el valor asociado, ya que el mapa asegura que no puedes duplicar claves en la colección. Internamente, Kotlin usa la colección Java Map para implementar los mapas.
A diferencia de las interfaces List y Set en Kotlin que extienden la interfaz Collection, la interfaz Map no extiende nada. Algunas de las propiedades y funciones disponibles en esta interfaz se muestran a [g1] continuación. Observa como solo se permite hacer consultas, al definir una colección inmutable.

• size: tamaño de la colección.

• isEmpty(): indica si el mapa está vacío.

• containsKey(key: K): indica si el mapa contiene una clave.

• containsValue(value: V): indica si el mapa contiene un valor.

• get(key: K): valor asociado a la llave dada o null si no se encuentra.

• keys: devuelve un Set inmutable con todas las claves en el mapa.

• values: Collection inmutable de todos los valores en el mapa.

mapOf() crea un mapa inmutable compuesto por una lista de pares, donde el primer valor es la clave, y el segundo es el valor. Devuelve un objeto de tipo Map.

val prefijos: Map<Int, String> = mapOf(34 to "España", 1 to "USA", 
                                                           233 to "Ghana")
for ((key, value) in prefijos) {
    println("$key es el código telefónico de $value")
}

Podemos obtener el valor de una clave usando la función get(). También podemos usar los corchetes como un atajo para get().

print(prefijos.get(34)) // España
print(prefijos[34])     // España 

La interfaz MutableMap no extiende la interfaz MutableCollection; su único padre es la interfaz Map. Este anula las propiedades keys, entries y values de la interfaz padre para poder redefinirlas. Además, incluye algunas funciones extra como:

• put(key: K, value: V) inserta el par clave-valor en el mapa. Devolverá el valor previo enlazado con la clave o null si la clave no existía.
  r

• emove(key: K) borra la clave y su valor enlazado.

• putAll(from: Map<out K, V>) agrega nuevos pares clave-valor desde otro mapa. Si una clave ya existente será actualizada con el nuevo valor.

• clear() elimina todos los elementos del mapa.

mutableMapOf() permite crear un mapa mutable sin indicar la implementación:

val monedas: MutableMap<String, String> = mutableMapOf("euro" to "España", 
                                  "dolar" to "EEUU", "libra" to "UK")
println("Paises ${ monedas.values}") 
println("Monedas ${ monedas.keys}") 
monedas.put("cedi", "Ghana")
monedas.remove("dolar")  

Para indicar implementaciones específicas dispones de: hashMapOf() para crear un mapa de tipo LinkedHashMap., donde puedes consultar el orden en que los elementos fueron insertados, y sortedMapOf() para SortedMap, en el cual todas las entradas se almacenan en un orden de clave ascendente.

fuente:https://www.androidcurso.com/index.php/99-kotlin/925-colecciones-en-kotlin-list-set-y-map

Para los que vienen de otro lenguaje como python los maps son diccionarios 😃

Código de la clase

fun main (args: Array<String>){
    //son de clave valor
    //para cada clave hay un valor

    //mapa inmutable
    var edadHeroes = mapOf(
            "Ironman" to 35,
            "Spiderman" to  23,
            "Capitan America" to 99
    )
    println(edadHeroes)

    //mapa mutable
    val edadHeroesMutable = mutableMapOf(
            "Ironman" to 35,
            "Spiderman" to  23,
            "Capitan America" to 99
    )
    println(edadHeroesMutable)

    //agregamos elemento
    edadHeroesMutable.put("Wolverine", 45)
    println(edadHeroesMutable)

    edadHeroesMutable["Storm"] = 30
    println(edadHeroesMutable)

    //podemos hacer get a la lista mutable o imutable
    val edadIronman = edadHeroes["Ironman"]
    println(edadIronman)

    //eliminar
    edadHeroesMutable.remove("Wolverine")
    println(edadHeroesMutable)

    //vemos llaves
    println(edadHeroesMutable.keys)

    //vemos valores
    println(edadHeroesMutable.values)
}

Como nota adicional, el recuperar valores por medio de su Key en un map , existe sensibilidad a mayusculas y minusculas, osea, no es lo mismo recuperar

val edadIronman= edadSuperHeroesMutable["Ironman"] // Retorna 35
val edadIronman= edadSuperHeroesMutable["ironman"] //Retorna null

Si estás buscando almacenar una lista de elementos con un orden específico y debes tener acceso a ellos mediante un índice, listOf es una buena opción. Es una lista inmutable, lo que significa que una vez que se ha creado, no se puede modificar.

Si estás buscando almacenar elementos con una clave y un valor asociado, y debes tener acceso a ellos mediante la clave, mapOf es una buena opción. Es un mapa inmutable, lo que significa que una vez que se ha creado, no se puede modificar.

En ambos casos podrías usar MutableList, MutableMap respectivamente para poder modificar y actualizar los elementos contenidos en ellos.

Creé un map con una lista de medicamentos que puede modificarse.

import java.util.Scanner

fun main() {

    val medication = mutableMapOf <String, String> (

    )
    val sc = Scanner(System.`in`)
    var agregarMed = true
    if (agregarMed) {


        do  {
        // código para agregar medicamentos al mapa

        println("Escriba el nombre del medicamento")
        val medicationName = sc.nextLine()
        println("Ingrese la hora en que debe tomarlo :: Ej 8:00 ::")
        val time = sc.nextLine()
        medication.put(medicationName, time)
        println("Desea agregar más medicamentos? (S/N)")
        var continuar = sc.nextLine()

    } while (continuar.equals("S", true))



    }

    if (!medication.isEmpty()) {
        printerLines(50)
        println("Lista de medicamentos")
        println(medication)
    } else {
        printerLines(50)
        print("No hay medicamentos")

    }
}

Deseo crear una app que sirva para los ancianos en su día a día.

 //Map inmutable no se puede eliminar o cambiar su contenido
    val edadSuperHeroes = mapOf(
        "Ironman" to 35, "Spiderman" to 23,
        "Capitán América" to 99
    )
    println(edadSuperHeroes)

    //Map mutable
    val edadSuperHeroesMutable = mutableMapOf(
        "Ironman" to 35, "Spiderman" to 23,
        "Capitán América" to 99
    )

    println(edadSuperHeroesMutable)

    //Adicionar elementos con put
    edadSuperHeroesMutable.put("Wolwerine", 45)

    println(edadSuperHeroesMutable)

    //Otra forma de adicionar es convertir put en una asignación
    edadSuperHeroesMutable["Storm"] = 30

    println(edadSuperHeroesMutable)

    //Obtener un valor del map
    val edadIronman = edadSuperHeroesMutable["Ironman"]
    println(edadIronman)

    //Eliminar elementos del map
    edadSuperHeroesMutable.remove("Wolwerine")
    println(edadSuperHeroesMutable)

    //Conocer todos las claves de un map
    println(edadSuperHeroesMutable.keys)

    //Conocer todos los valores de un map
    println(edadSuperHeroesMutable.values)

Usando lo aprendido en los ciclos podríamos recorrer estos mapas con un ciclo for de la siguiente manera:

for (hero in mutableSuperHeroesAges) println("Hero: ${hero.key} - Age: ${hero.value}")

O puedes definir mutableSuperHeroesAges.entries para tener acceso a su key, value inmediatamente también. Las posibilidades son muchas depende lo que quieras lograr.

Consejo puedes ejecturar el programa con Ctrl + shift + f10 así me funciona en Windows 10

fun main(args: Array<String>) {
  //No tienen forma de acceder por un orden espectifico

  //Inmutable
  val edadSuperHeroes = mapOf("IronMan" to 35, "Spiderman" to 23, "Capitan America" to 99)

  println(edadSuperHeroes)
  /*{IronMan=35, Spiderman=23, Capitan America=99}*/

  //Mutable
    val edadSuperHeroesMutable = mutableMapOf("IronMan" to 35, "Spiderman" to 23, "Capitan America" to 99)
     println(edadSuperHeroesMutable)
       /*{IronMan=35, Spiderman=23, Capitan America=99}*/

       //Agregar a la lista

       //put

       edadSuperHeroesMutable.put("Wolverine",45)
       println(edadSuperHeroesMutable) 
              /*{IronMan=35, Spiderman=23, Capitas America=99, Wolverine=45}*/

       //covertir asignación
        edadSuperHeroesMutable["Storm"]=30;
   println(edadSuperHeroesMutable) 
   /*{IronMan=35, Spiderman=23, Capitas America=99, Wolverine=45, Storm=30}*/

   /*Obtener un valor*/
   val edadIroman = edadSuperHeroesMutable["IronMan"]
  println(edadIroman)/*35*/

  /*Eliminar*/
  edadSuperHeroesMutable.remove("Wolverine")
  println(edadSuperHeroesMutable) 

  /*Se puede conocer todas las listas y/o valoress del mapa*/
  
  println(edadSuperHeroesMutable.keys)
  /*[IronMan, Spiderman, Capitan America, Storm*/
  println(edadSuperHeroesMutable.values)
  /*[35, 23, 99, 30]*/
}

fun main(args: Array<String>) {
	
// mapa inmutable
var edadSuperHeroes = mapOf(
		"Iroman" to 35,
		"Spiderman" to 23,
		"Capitan America" to 99,
	)
	
println(edadSuperHeroes)

// mapa mutable
var edadDeSuperHeroesMutale = mutableMapOf(
"Ironman" to 35,
"Sipiderman" to 23,
"Capitan America" to 99
)

println(edadSuperHeroesMutable)

// agregar un elemento al mapa
edadDeSuperHeroesMutable.put("Wolverine", 45)

// agregar elemento al mapa en forma de asignación
edadSuperHeroesMutable["Storm"] = 23

// acceder a un elemento del mapa
val edadIroman = edadSuperHeroesMutable['Ironman']

// eliminar elementos del mapa
edadSuperHeroesMutable.remove(key: 'Wolverine')

// regresar la lista de claves del mapa
println(edadSuperHeroesMutable.keys)
	
}

var edadHeroes = mapOf(
        "Ironman" to 35,
        "Spiderman" to  23,
        "Capitan America" to 99
    )
    println(edadHeroes)

    val edadHeroesMutable = mutableMapOf(
        "Ironman" to 35,
        "Spiderman" to  23,
        "Capitan America" to 99
    )
    println(edadHeroesMutable)

    edadHeroesMutable.put("Wolverine", 45)
    println(edadHeroesMutable)

    edadHeroesMutable["Storm"] = 30
    println(edadHeroesMutable)

    val edadIronman = edadHeroes["Ironman"]
    println(edadIronman)

    edadHeroesMutable.remove("Wolverine")
    println(edadHeroesMutable)

    println(edadHeroesMutable.keys)

    println(edadHeroesMutable.values)

Muy buena explicación por medio del Universo Marvel.