Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Maps

23/37
Recursos

Aportes 12

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.





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 😃

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

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

 //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.

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

Muy buena explicación por medio del Universo Marvel.

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