Wie arbeitet man mit Sammlungen in Kotlin?

In Kotlin stellen Sammlungen Gruppen von Objekten dar. Sie können veränderbar (mutable) oder unveränderlich (immutable) sein.

Unveränderliche Sammlungen (Immutable):

• Der Inhalt kann nach der Erstellung nicht geändert werden.
• Sie sind beim Lesen threadsicher.
• Grundtypen: List, Set, Map.

val numbers: List<Int> = listOf(1, 2, 3) // Erstellen einer unveränderlichen Liste
// numbers.add(4) // Kompilierungsfehler: unveränderliche Sammlung

Veränderbare Sammlungen (Mutable):

• Der Inhalt kann geändert werden (Hinzufügen, Entfernen, Ändern von Elementen).
• Sind standardmäßig nicht threadsicher (manuelle Synchronisation erforderlich).
• Grundtypen: MutableList, MutableSet, MutableMap.

val mutableNumbers: MutableList<Int> = mutableListOf(1, 2, 3) // Erstellen einer veränderbaren Liste
mutableNumbers.add(4) // Element hinzufügen
mutableNumbers.remove(2) // Element entfernen

Haupttypen von Sammlungen:

• List: Geordnete Sammlung, die Duplikate zulässt. Zugriff über Index.

  val names: List<String> = listOf("Alice", "Bob", "Alice")
  println(names[0]) // "Alice"
  

• Set: Nicht-ordentliche Sammlung, die keine Duplikate zulässt. Elemente sind eindeutig.

  val uniqueNumbers: Set<Int> = setOf(1, 2, 2, 3)
  println(uniqueNumbers) // [1, 2, 3]
  

• Map: Sammlung von Schlüssel-Wert-Paaren. Jeder Schlüssel ist eindeutig.

  val ages: Map<String, Int> = mapOf("Alice" to 30, "Bob" to 25)
  println(ages["Alice"]) // 30
  

Erweiterungsfunktionen für Sammlungen (Higher-Order-Funktionen):

Kotlin bietet viele mächtige Erweiterungsfunktionen zur Verarbeitung von Sammlungen:

• filter: Erstellt eine neue Sammlung, die nur Elemente enthält, die eine Bedingung erfüllen.

  val evenNumbers = numbers.filter { it % 2 == 0 } // [2]
  

• map: Transformiert jedes Element in ein neues Element, um eine neue Sammlung zu erstellen.

  val squaredNumbers = numbers.map { it * it } // [1, 4, 9]
  

• forEach: Führt eine Aktion für jedes Element aus.

  numbers.forEach { println(it) } // Gibt 1, 2, 3 Zeile für Zeile aus
  

• reduce: Kombiniert alle Elemente zu einem Wert unter Verwendung einer Operation.

  val sum = numbers.reduce { acc, i -> acc + i } // 6
  

• fold: Ähnlich wie reduce, aber mit Anfangswert.

  val sumWithInitial = numbers.fold(10) { acc, i -> acc + i } // 16 (10 + 1 + 2 + 3)
  

• sortedBy: Sortiert die Sammlung nach einem Wert, der aus jedem Element extrahiert wird.

  val sortedNames = listOf("Charlie", "Alice", "Bob").sortedBy { it } // [Alice, Bob, Charlie]
  

• groupBy: Gruppiert Elemente nach einem Schlüssel, der aus jedem Element extrahiert wird.

  val groupedNumbers = numbers.groupBy { if (it % 2 == 0) "even" else "odd" } // {odd=[1, 3], even=[2]}
  

Konvertierung zwischen Sammlungstypen:

Es ist einfach, einen Sammlungstyp in einen anderen zu konvertieren, sowie zwischen veränderbaren und unveränderlichen Versionen:

val mutableList: MutableList<Int> = listOf(1, 2, 3).toMutableList()
val immutableList: List<Int> = mutableListOf(4, 5, 6).toList()

Die Arbeit mit Sammlungen in Kotlin wird durch die umfangreiche Standardbibliothek und Erweiterungsfunktionen erheblich vereinfacht.