El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Col·leccions i Genèrics

Següent ►
►

En aquest tema, explorarem les col·leccions i els genèrics en Kotlin. Les col·leccions són una part fonamental de qualsevol llenguatge de programació, ja que permeten emmagatzemar i manipular grups de dades. Els genèrics, per altra banda, permeten escriure codi més flexible i reutilitzable.

Col·leccions en Kotlin

Kotlin proporciona diverses col·leccions estàndard, com ara llistes, conjunts i mapes. Aquestes col·leccions poden ser mutables o immutables.

Llistes

Les llistes són col·leccions ordenades d'elements. Kotlin ofereix dues versions de llistes:

  • List: Immutables, no es poden modificar després de la seva creació.
  • MutableList: Mutables, es poden modificar després de la seva creació.

Exemple de List (Immutables)

val fruits = listOf("Apple", "Banana", "Cherry")
println(fruits) // Output: [Apple, Banana, Cherry]

Exemple de MutableList (Mutables)

val fruits = mutableListOf("Apple", "Banana")
fruits.add("Cherry")
println(fruits) // Output: [Apple, Banana, Cherry]

Conjunts

Els conjunts són col·leccions no ordenades d'elements únics. Kotlin ofereix dues versions de conjunts:

  • Set: Immutables.
  • MutableSet: Mutables.

Exemple de Set (Immutables)

val numbers = setOf(1, 2, 3, 4, 4)
println(numbers) // Output: [1, 2, 3, 4]

Exemple de MutableSet (Mutables)

val numbers = mutableSetOf(1, 2, 3)
numbers.add(4)
println(numbers) // Output: [1, 2, 3, 4]

Mapes

Els mapes són col·leccions de parelles clau-valor. Kotlin ofereix dues versions de mapes:

  • Map: Immutables.
  • MutableMap: Mutables.

Exemple de Map (Immutables)

val countryCodes = mapOf("US" to "United States", "CA" to "Canada")
println(countryCodes) // Output: {US=United States, CA=Canada}

Exemple de MutableMap (Mutables)

val countryCodes = mutableMapOf("US" to "United States")
countryCodes["CA"] = "Canada"
println(countryCodes) // Output: {US=United States, CA=Canada}

Genèrics en Kotlin

Els genèrics permeten definir classes, interfícies i funcions que poden operar amb qualsevol tipus de dades, proporcionant així una major flexibilitat i reutilització del codi.

Classes Genèriques

Una classe genèrica és una classe que pot treballar amb qualsevol tipus de dades. Es defineix utilitzant paràmetres de tipus.

Exemple de Classe Genèrica

class Box<T>(val value: T)

val intBox = Box(1)
val stringBox = Box("Hello")

println(intBox.value) // Output: 1
println(stringBox.value) // Output: Hello

Funcions Genèriques

Les funcions genèriques són funcions que poden treballar amb qualsevol tipus de dades. Es defineixen utilitzant paràmetres de tipus.

Exemple de Funció Genèrica

fun <T> printItem(item: T) {
    println(item)
}

printItem(1) // Output: 1
printItem("Hello") // Output: Hello

Restriccions de Tipus

Els genèrics poden tenir restriccions de tipus per limitar els tipus de dades que poden acceptar.

Exemple de Restricció de Tipus

fun <T : Number> sum(a: T, b: T): Double {
    return a.toDouble() + b.toDouble()
}

println(sum(1, 2)) // Output: 3.0
println(sum(1.5, 2.5)) // Output: 4.0

Exercicis Pràctics

Exercici 1: Crear una Llista Mutable

Crea una MutableList de tipus String i afegeix-hi tres elements. Després, imprimeix la llista.

Solució

val animals = mutableListOf("Dog", "Cat")
animals.add("Elephant")
println(animals) // Output: [Dog, Cat, Elephant]

Exercici 2: Crear una Classe Genèrica

Crea una classe genèrica Pair que emmagatzemi dues valors de qualsevol tipus. Després, crea una instància de Pair amb dos Int i una altra amb dos String.

Solució

class Pair<A, B>(val first: A, val second: B)

val intPair = Pair(1, 2)
val stringPair = Pair("Hello", "World")

println(intPair.first) // Output: 1
println(intPair.second) // Output: 2
println(stringPair.first) // Output: Hello
println(stringPair.second) // Output: World

Resum

En aquesta secció, hem après sobre les col·leccions i els genèrics en Kotlin. Hem vist com utilitzar llistes, conjunts i mapes, tant immutables com mutables. També hem explorat com crear classes i funcions genèriques per escriure codi més flexible i reutilitzable. Els exercicis pràctics ens han ajudat a consolidar aquests conceptes. En el proper tema, explorarem les funcions d'extensió en Kotlin.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats