Standardfunktionen für Arrays und Collections in Kotlin

In Kotlin gibt es mehrere Standardfunktionen für Arrays und Sammlungen wie Listen, Sets oder Maps, die die Arbeit mit diesen Datenstrukturen vereinfachen und effizienter gestalten. Im Folgenden werden einige dieser Funktionen mitsamt Codebeispielen und gängigen Anwendungsfällen vorgestellt.

isEmpty() und isNotEmpty()

Die isEmpty()-Funktion gibt true zurück, wenn ein Array oder Sammlung wie Liste, Set oder Map leer ist, d.h. keine Elemente enthält; andernfalls gibt sie false zurück.

isNotEmpty(): Diese Funktion gibt true zurück, wenn ein Array oder Sammlung mindestens ein Element enthält; andernfalls gibt sie false zurück.

fun main() {
    val emptyArray = arrayOf<Int>()
    val nonEmptyArray = arrayOf(1, 2, 3)

    val isEmpty = emptyArray.isEmpty() 
    println(isEmpty)  // Ergebnis: true
    val isNotEmpty = nonEmptyArray.isNotEmpty() 
    println(isNotEmpty)  // Ergebnis: true
}

Anwendungsbeispiel: Beim Arbeiten mit Arrays oder Sammlungen kann man isEmpty() oder isNotEmpty() verwenden, um zu überprüfen, ob die Datenstruktur Elemente enthält oder nicht, bevor man darauf zugreift oder Operationen darauf ausführt.

count()

Die Funktion gibt die Anzahl der Elemente in einem Array oder einer Sammlung (Liste oder Set) zurück. Ein Beispiel für die Verwendung von count() könnte wie folgt aussehen:

fun main() {

    val arrayOfNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
    val count = arrayOfNumbers.count()
    println("Number of elements in the array: $count") // Ausgabe: 'Number of elements in array: 5'
}

Die count()-Funktion kann auch mit einem prädikativen Lambda-Ausdruck verwendet werden, um die Anzahl der Elemente zu zählen, die eine bestimmte Bedingung erfüllen. Im nachstehenden Beispiel wird die Anzahl der geraden Zahlen in einem Array ermittelt:

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
    val evenCount = arrayOfNumbers.count { it % 2 == 0 }
    println("Total even numbers in the array: $evenCount") // Ausgabe: 'Total even numbers in the array: 2'
}

In dem Fall prüft der Lambda-Ausdruck, ob das Element (dargestellt durch it) modulo 2 gleich 0 ist, was bedeutet, dass es eine gerade Zahl ist. Die count()-Funktion gibt die Anzahl der Elemente zurück, die die Bedingung im Lambda-Ausdruck erfüllen.

Anwendungsbeispiel: Die count()-Funktion wird in vielen Situationen eingesetzt, in denen eine Bedingung auf alle Elemente einer Sammlung angewendet und die Anzahl der Elemente, die diese Bedingung erfüllen, ermittelt werden soll. Zum Beispiel kann sie verwendet werden, um String-Elemente zu zählen, die eine bestimmte Länge haben oder ein bestimmtes Muster enthalten.

contains()

Die contains()-Funktion in Kotlin ist eine praktische Methode, um zu überprüfen, ob ein Array oder eine Sammlung (List oder Set) ein bestimmtes Element enthält. Sie gibt true zurück, wenn das Element in der Sammlung vorhanden ist, andernfalls false.

fun main() {
    val arrayOfNames: Array<String> = arrayOf("Alice", "Bart", "Charlie", "Donald")

    // Verwendung von contains()
    val isAlicePresent = arrayOfNames.contains("Alice")
    println(isAlicePresent) // Ausgabe: true

   // Verwendung des in-Operators
   val isChristophPresent = "Christoph" in arrayOfNames
   println(isChristophPresent) // Ausgabe: false
}

Anwendungsfall: Ein gängiger Anwendungsfall für die contains()-Funktion in Kotlin besteht darin, zu überprüfen, ob ein bestimmtes Element in einer Sammlung enthalten ist, bevor eine bestimmte Aktion ausgeführt wird (Zum Beispiel Überprüfung, ob ein Benutzername in Datenbanken vorhanden ist). 

first() und last()

Die first()– und last()-Funktionen in Kotlin sind nützlich, um das erste bzw. letzte Element einer Sammlung abzurufen. Sie können auch mit einer Bedingung verwendet werden, um das erste bzw. letzte Element zu erhalten, das die angegebene Bedingung erfüllt. Hier sind einige Beispiele und Anwendungsfälle:

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(10, 20, 30, 40, 50)

    val firstElement = arrayOfNumbers.first()
    val lastElement = arrayOfNumbers.last()

    println("First element: $firstElement") // Ausgabe: 'First element: 10'
    println("Last element: $lastElement") // Ausgabe: 'Last element: 50'
}

Abrufen des ersten und letzten Elements, das eine Bedingung erfüllt:

fun main() {
    val arrayOfWords: Array<String> = arrayOf("apple", "banana", "cherry", "orange", "peach")

    val firstLongWord = arrayOfWords.first { it.length > 5 }
    val lastLongWord = arrayOfWords.last { it.length > 5 }

    println("First long word: $firstLongWord") // Ausgabe: 'First long word: banana'
    println("Last long word: $lastLongWord") // Ausgabe: 'Last long word: orange'
}

Anwendungsbeispiel: Ermitteln von Anfangs- oder Endpunkten in einer Sammlung von Besucherzeiten (ein Array mit Zeitstempeln), um den Zeitpunkt des ersten und des letzten Besuchs zu ermitteln.

maxOrNull() und minOrNull()

Funktionen maxOrNull() und minOrNull() geben das größte bzw. kleinste Element eines Arrays oder einer Sammlung zurück oder null, wenn das Array leer ist.

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
    val maxValue = arrayOfNumbers.maxOrNull() 
    println(maxValue)  // Ergebnis: 5
    val minValue = arrayOfNumbers.minOrNull() 
    println(minValue)  // Ergebnis: 1
}

Anwendungsbeispiel: Ermitteln einer Preisspanne für eine Produktkategorie in einem Onlineshop.

average()

Die average()-Funktion in Kotlin ist nützlich, um den Durchschnittswert eines Arrays oder einer Sammlung von numerischen Werten zu berechnen. Diese Funktion ist für Sammlungen mit Elementen des Typs Byte, Short, Int, Long, Float und Double verfügbar. Nachstehend ist ein Beispiel:

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(10, 20, 30, 40, 50)
    val averageValue = arrayOfNumbers.average()
    println("Average value: $averageValue")  // Ausgabe: 'Average value: 30.0'
}

Anwendungsbeispiel: Gängige Anwendungsfälle für die average()-Funktion in Kotlin sind die Berechnung des Durchschnitts von numerischen Daten, wie z. B. die Ermittlung von Durchschnittspreisen, Durchschnittspunktzahlen oder Durchschnittstemperaturen.

sorted(), sortedDescending(), sortedBy(), sortedByDescending()

In Kotlin gibt es mehrere Funktionen zum Sortieren von Arrays und Sammlungen in aufsteigender oder absteigender Reihenfolge oder anhand von benutzerdefinierten Kriterien. Hier sind die Funktionen und einige Anwendungsfälle:

sorted()

Die sorted()-Funktion sortiert ein Array oder eine Sammlung von Zahlen oder Zeichenketten in aufsteigender Reihenfolge.

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(300, 100, 200, 400, 500)
    val sortedNumbers = arrayOfNumbers.sorted()
    println("Sorted numbers: $sortedNumbers")  // Ausgabe: 'Sorted numbers: [100, 200, 300, 400, 500]'
}

sortedDescending()

Die sortedDescending()-Funktion sortiert ein Array oder eine Sammlung von Zahlen oder Zeichenketten in absteigender Reihenfolge.

fun main() {
    val numbers = listOf(300, 100, 200, 400, 500)
    val sortedDescendingNumbers = numbers.sortedDescending()
    println("Sorted descending numbers: $sortedDescendingNumbers")  // Ausgabe: 'Sorted descending numbers: [500, 400, 300, 200, 100]'
}

sortedBy()

Diese Funktion sortiert ein Array oder eine Sammlung von Objekten anhand einer benutzerdefinierten Eigenschaft in aufsteigender Reihenfolge.

fun main() {
    val arrayOfWords: Array<String> = arrayOf("Paris", "Brisbane", "Rome", "Sydney", "Chicago")
    val sortedByLength = arrayOfWords.sortedBy { it.length }
    println("Words sorted by length: $sortedByLength")  // Ausgabe: 'Words sorted by length: [Rome, Paris, Sydney, Chicago, Brisbane]'
}

In diesem Beispiel ist arrayOfWords eine Liste von Strings. Die sortedBy()-Funktion wird verwendet, um die Liste basierend auf der Länge der Strings zu sortieren. Die Lambda-Funktion { it.length } gibt die Länge jedes Elements in der Liste zurück, und sortedBy() verwendet diese Länge, um die Elemente in aufsteigender Reihenfolge zu sortieren.

sortedByDescending()

Diese Funktion sortiert ein Array oder eine Sammlung anhand einer benutzerdefinierten Eigenschaft in absteigender Reihenfolge. Nachstehend ist ein Beispiel, bei dem ein Array von Zahlen basierend auf dem Rest ihrer Division durch 3 in absteigender Reihenfolge sortiert wird:

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(10, 9, 11, 53, 82)
    val sortedByModuloThree = arrayOfNumbers.sortedByDescending() { it % 3 }
    
    println("Numbers sorted by their modulo 3: $sortedByModuloThree")
    // Ausgabe: 'Numbers sorted by their modulo 3: [11, 53, 10, 82, 9]'
}

Anwendungsbeispiele: Die sorted(), sortedDescending(), sortedBy() und sortedByDescending() Funktionen sind nützlich, um Sammlungen basierend auf verschiedenen Kriterien zu sortieren. Sie können in vielen Anwendungsfällen verwendet werden, z. B. um Ranglisten zu erstellen, Daten für Berichte oder Präsentationen vorzubereiten oder um Benutzerinteraktionen in einer Anwendung zu optimieren.

distinct()

Die distinct()-Funktion in Kotlin wird verwendet, um Duplikate aus einem Array oder einer Sammlung zu entfernen und eine neue Sammlung mit nur einzigartigen Elementen zurückzugeben.

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(10, 20, 30, 20, 10, 40, 50, 40, 60)
    val distinctNumbers: List<Int> = arrayOfNumbers.distinct()

    println("Distinct numbers: $distinctNumbers") // Ausgabe: 'Distinct numbers: [10, 20, 30, 40, 50, 60]'
}

In diesem Beispiel entfernt distinct() die Duplikate aus dem Array arrayOfNumbers und gibt eine neue Liste distinctNumbers mit den einzigartigen Zahlen zurück.

Ein Beispiel für Entfernen von doppelten Strings aus einem Array:

fun main() {
    val arrayOfwords: Array<String> = arrayOf("apple", "orange", "banana", "apple", "orange")
    val distinctWords: List<String> = arrayOfwords.distinct()

    println("Distinct words: $distinctWords") // Ausgabe: 'Distinct words: [apple, orange, banana]'
}

indexOf() und lastIndexOf()

Die indexOf()– und lastIndexOf()-Funktionen in Kotlin werden verwendet, um den Index eines bestimmten Elements in einem Array oder in einer Sammlung zu finden.

indexOf()

Die indexOf()-Funktion gibt den ersten Index zurück, an dem das gesuchte Element gefunden wird. Wenn das Element nicht vorhanden ist, gibt die Funktion -1 zurück.

fun main() {
    val arrayWithColors: Array<String> = arrayOf("red", "green", "blue", "yellow", "green", "blue")
    val yellowIndex = arrayWithColors.indexOf("yellow")

    println("First index of yellow: $yellowIndex") // Ausgabe: 'First index of yellow: 3'
}

In diesem Beispiel gibt die indexOf()-Funktion den ersten Index zurück, an dem das Wort yellow in dem Array arrayWithColors gefunden wird.

lastIndexOf()

Die lastIndexOf()-Funktion in Kotlin wird verwendet, um den letzten Index eines bestimmten Elements in einem Array oder in einer Sammlung, wie einer Liste oder einem Array, zu finden. Diese Funktion durchsucht die Sammlung rückwärts, beginnend am Ende der Sammlung, und gibt den Index des letzten Vorkommens des gesuchten Elements zurück. Wenn das Element nicht in der Sammlung vorhanden ist, gibt die Funktion -1 zurück.

fun main() {
    val arrayWithColors: Array<String> = arrayOf("yellow", "red", "green", "blue", "yellow", "green", "red")
    val lastRedIndex = arrayWithColors.lastIndexOf("red")

    println("Last index of red: $lastRedIndex") // Ausgabe: 'Last index of red: 6'
}

Anwendungsbeispiel: Ermitteln der Häufigkeit eines Elements in einer Sammlung, indem indexOf() und lastIndexOf() verwendet werden, um den ersten und letzten Index des Elements zu finden und dann den Bereich zwischen diesen Indizes zu durchlaufen.

forEach()

Die forEach()-Funktion in Kotlin ist eine höhere Ordnungsfunktion, die es ermöglicht, über die Elemente eines Arrays oder einer Sammlung zu iterieren und eine bestimmte Aktion für jedes Element auszuführen. 

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(10, 20, 30, 40, 50)

    arrayOfNumbers.forEach { number ->
         println("The current element is: $number")
    }
}

In diesem Fall wird die forEach()-Funktion verwendet, um über die Elemente des Arrays arrayOfNumbers zu iterieren. Für jedes Element im Array wird der Lambda-Ausdruck innerhalb der geschweiften Klammern {} ausgeführt.

Alternativ kann man auch die implizite it-Variable verwenden. Ein impliziter Name ist ein vordefinierter, automatisch vergebener Name für eine Variable oder ein Objekt, ohne dass der Programmierer diesen explizit angeben muss. In Kotlin wird die implizite Variable it verwendet, um das aktuelle Element in einem Lambda-Ausdruck zu referenzieren, wenn kein expliziter Name angegeben wird.

fun main() {
    val arrayOfNumbers: Array<Int> = arrayOf(10, 20, 30, 40, 50)

    arrayOfNumbers.forEach {
         println("The current element is: $it")
    }
}

Anwendungsbeispiel: Das Senden von personalisierten E-Mails an eine Liste von Benutzern.

map()

In Kotlin ist map() eine Funktion, die auf Arrays oder Sammlungen wie Listen oder Sets angewendet werden kann. Sie dient dazu, eine neue Sammlung zu erstellen, indem sie jedes Element der ursprünglichen Sammlung mithilfe einer gegebenen Transformationsfunktion ändert. Die Transformationsfunktion wird als Lambda-Ausdruck bereitgestellt.

fun main() {
   val arrayOfNumbers = arrayOf(1, 2, 3, 4, 5)
   val doubleArray = arrayOfNumbers.map { it * 2 }  
   println(doubleArray)  // Eregbnis: [2, 4, 6, 8, 10]
}

Anwendungsbeispiel: Ein gängiger Anwendungsfall für die map()-Funktion ist die Umwandlung von Elementen einer Sammlung in eine andere Form oder Datentyp. Zum Beispiel könnte man eine Liste von Preisen in einer Währung in eine Liste von Preisen in einer anderen Währung umrechnen.

filter()

Die filter()-Funktion in Kotlin ist eine Erweiterungsfunktion, die auf Sammlungen wie Listen, Sets oder Arrays angewendet werden kann. Sie ermöglicht das Erstellen einer neuen Sammlung, die nur die Elemente enthält, die eine bestimmte Bedingung erfüllen. Die Bedingung wird als Lambda-Ausdruck bereitgestellt.

fun main() {
   val arrayOfNumbers = arrayOf(1, 2, 3, 4, 5)
   val evenArray = arrayOfNumbers.filter { it % 2 == 0 } 
   println(evenArray)  // Ergebnis: [2, 4]
}

Anwendungsbeispiel: Filtern von Schülern, die einen bestimmten Mindestnotendurchschnitt erreicht haben.