Standardfunktionen für die Arbeit mit Strings in Kotlin

In Kotlin gibt es mehrere Standardfunktionen, die entwickelt wurden, um häufige Aufgabenstellungen effizienter und einfacher zu lösen. Diese Funktionen sind Teil der Kotlin-Standardbibliothek und können direkt im Code verwendet werden. In den folgenden Kapiteln werden wir uns mit häufig verwendeten Standardfunktionen für die Arbeit mit Strings, mathematischen Operationen, Arrays, Collections sowie Datum und Zeit befassen. Zu jeder Funktion werden ihr Syntax und Arbeitsweise erklärt sowie gängige Anwendungsfallbeispiele genannt.

Einige der nützlichsten und am häufigsten genutzten Funktionen für die Strings sind:

toUpperCase() und toLowerCase()

Funktionen toUpperCase() und toLowerCase() konvertieren einen String in Groß- bzw. Kleinbuchstaben.

fun main() {
    val myString = "I am learning Kotlin!"
    val upperCaseStr = myString.toUpperCase()    // Aufruf der Standardfunktion 'toUpperCase' auf Variable 'myString', um alle Buchstaben des Strings in Großbuchstaben umzuwandeln.
    println(upperCaseStr)   // Ausgabe: I AM LEARNING KOTLIN!
}

In diesem Beispiel wird die Standardfunktion toUpperCase() auf dem Objekt aufgerufen, auf das die Variable myString verweist, um alle Buchstaben des Strings in Großbuchstaben umzuwandeln. Der Aufruf erfolgt durch das Anhängen des Funktionsnamens toUpperCase an den Variablennamen mit einem Punktoperator, gefolgt von den Argumenten in Klammern. In diesem Fall wurden keine weiteren Argumente an die Funktion übergeben, daher sind die Klammern leer.

Mit der Funktion toLowerCase() erreicht man das Gegenteil: Alle Buchstaben einer Zeichenkette werden in Kleinbuchstaben umgewandelt:

fun main() {
    val myString = "I am learning Kotlin!"
    val lowerCaseStr = myString.toLowerCase()
    println(lowerCaseStr)   // Ausgabe: 'i am learning kotlin!'
}

Anwendungsbeispiel: Die Funktionen toUpperCase() und toLowerCase() können zur Normalisierung von Benutzereingaben genutz werden. Oftmals geben Benutzer Daten in unterschiedlichen Schreibweisen ein, z. B. bei der Eingabe von E-Mail-Adressen oder Benutzernamen. Um sicherzustellen, dass die Daten konsistent gespeichert und verarbeitet werden, können toLowerCase() oder toUpperCase() verwendet werden, um alle Zeichen in Klein- bzw. Großbuchstaben umzuwandeln, bevor sie in einer Datenbank gespeichert oder für weitere Verarbeitung verwendet werden.

capitalize() und decapitalize()

Die Funktionen capitalize(), decapitalize() ändert den ersten Buchstaben eines Strings in einen Groß- bzw. Kleinbuchstaben.

fun main() {
    val myString = "hello, world!"
    val capitalizedString = myString.capitalize() 
    println(capitalizedString)   // Ergebnis: "Hello, world!"
    val decapitalizedString = capitalizedString.decapitalize()    // Ergebnis: "hello, world!"
    println(decapitalizedString)
}

Anwendungsbeispiel: Die Funktionen capitalize() und decapitalize() können verwendet werden, um sicherzustellen, dass ein Text die gewünschte Formatierung hat (z. B. Anrede in einem Brief oder Titel in einer Überschrift).

trim()

Die Funktion trim() entfernt Leerzeichen am Anfang und am Ende eines Strings.

fun main() {
    val userName = " Donald Firestone "
    var trimmedString = userName.trim()
    println(trimmedString)  // Ausgabe: 'Donald Firestone'
}

Anwendungsbeispiel: Ein gängiger Anwendungsfall für die trim()-Funktion ist die Bereinigung von Benutzereingaben oder Textdaten aus externen Quellen. Dabei werden unerwünschte Leerzeichen am Anfang und Ende des Strings entfernt, um mögliche Formatierungsprobleme oder falsche Verarbeitung der Daten zu vermeiden.

Das obige Beispiel stellt einen solchen Fall dar: Der Benutzer hat seinen Namen mit zwei Leerzeichen am Anfang und am Ende eingegeben – ‚ Donald Firestone ‚. Mithilfe der trim()-Funktion wurden die überflüssigen Leerzeichen entfernt, sodass nur der tatsächlich eingegebene Name übrig geblieben ist.

trimStart() und trimEnd()

Standardfunktionen trimStart() und trimEnd() entfernen Leerzeichen nur am Anfang bzw. am Ende eines Strings.

fun main() {
    val myString = " Hello, Kotlin! "
    val trimmedStartStr = myString.trimStart() 
    println(trimmedStartStr)      // Ergebnis: 'Hello, world! '
    val trimmedEndStr = trimmedStartStr.trimEnd() 
    println(trimmedEndStr)       // Ergebnis: 'Hello, world!' 
}

substring()

Die Funktion substring() gibt einen Teil des Strings zurück, der durch den angegebenen Bereich definiert ist.

fun main() {
    val myString = "The quick brown fox jumps over the lazy dog."
    val result = myString.substring(4, 19)
    println(result)   // Ausgabe: 'quick brown fox'
}

In diesem Beispiel wird die substring()-Funktion auf dem String-Objekt myString aufgerufen. Dabei werden die Parameter 4 und 19 übergeben, um einen Teilstring (Teilzeichenkette) aus dem ursprünglichen String zu extrahieren. Die erste Zahl 4 ist der Startindex (einschließlich), und die zweite Zahl 19 ist der Endindex (ausschließlich). In diesem Fall wird der Teilstring vom Index 4 bis zum Index 18 extrahiert.

Anwendungsbeispiel: Bei der Arbeit mit Datums- und Zeitangaben in Textform kann substring() verwendet werden, um spezifische Teile wie Jahr, Monat oder Tag aus einem Datumsstring zu extrahieren.

replace()

Die Funktion replace() ersetzt alle Vorkommen eines Zeichens oder einer Zeichenkette im String durch einen anderen Wert.

fun main() {
      val myString = "Hello, world!"
      val replacedStr = myString.replace("world", "Kotlin") 
      println(replacedStr)   // Ergebnis: 'Hello, Kotlin!'
}

In diesem Codebeispiel wird das Wort ‚world‘ im ursprünglichen String ‚Hello, world!‘ durch das Wort ‚Kotlin‘ ersetzt, und das Ergebnis ‚Hello, Kotlin!‘ wird auf der Konsole ausgegeben.

Anwendungsbeispiel Zensur von unangemessenen Inhalten: Bei der Verarbeitung von Benutzereingaben oder Textinhalten kann es erforderlich sein, unangemessene Wörter automatisiert zu zensieren. Dafür kann replace()-Funktion verwendet werden, um solche Wörter durch geeignete Platzhalter oder Sonderzeichen/Sterne zu ersetzen.

contains()

Die Standardfunktion contains() prüft, ob ein String ein bestimmtes Zeichen oder eine Zeichenkette enthält.

fun main() {
    val myString = "Hello, world!"
    val containsWorld = myString.contains("world") 
    println(containsWorld)   // Ergebnis: true
}

Anwendungsbeispiel Validierung von Benutzereingaben: Wenn die Benutzereingaben validiert werden müssen, z. B. um sicherzustellen, dass eine E-Mail-Adresse ein „@“-Zeichen enthält oder ein Passwort bestimmte Zeichen enthält, können die contains()-Funktion verwendet werden, um diese Anforderungen zu überprüfen.

startsWith() und endsWith()

Die Standardfunktionen startsWith() und endsWith() prüfen, ob ein String mit einem bestimmten Präfix bzw. Suffix beginnt oder endet.

fun main() {
    val myString = "Get your ducks in a row!"
    val startsWithHello = myString.startsWith("Get")
    val endsWithWorld = myString.endsWith("row!") 
    println(startsWithHello)    // Ausgabe: true
    println(endsWithWorld)      // Ausgabe: true
}

split()

Die Funktion split() teilt einen String in eine Liste von Teilstrings, die durch einen oder mehrere Trennzeichen getrennt sind.

fun main() {
    val myString = "one,two,three"
    val partsOfString = myString.split(",") 
    println(partsOfString)    // Ergebnis: ['one', 'two', 'three']
}

Anwendungsbeispiel: Ein Beispiel für die Verwendung von split() ist die Analyse von Benutzereingaben, wie z. B. Telefonnummern. Wenn ein Benutzer eine Telefonnummer eingibt, kann die Anwendung die split()-Funktion verwenden, um die Telefonnummer in verschiedene Teile aufzuteilen, wie z. B. die Ländervorwahl, die Vorwahl und die eigentliche Telefonnummer. Die einzelnen Teile können dann weiterverarbeitet oder validiert werden, um sicherzustellen, dass sie korrekt sind.

joinToString()

Die Funktion joinToString() verbindet Elemente einer Sammlung oder eines Arrays zu einem String mit optionalen Trennzeichen, Präfixen und Suffixen.

fun main() {
    val words = arrayOf("one", "two", "three")

    val joinedString = words.joinToString(separator = " - ") 
    println(joinedString)        // Ergebnis: 'one - two - three'
}

Anwendungsbeispiel: Ein Beispiel für die Verwendung von joinToString() ist das Zusammenführen von Elementen einer Liste oder eines Arrays in eine Zeichenfolge mit einem bestimmten Trennzeichen. Wenn eine Anwendung beispielsweise eine Liste von Benutzern hat und diese in einer Benutzeroberfläche anzeigen möchte, kann joinToString() verwendet werden, um die Liste in eine kommagetrennte Zeichenfolge umzuwandeln, die für den Benutzer leicht lesbar ist.

plus()

Die Standardfunktion plus() verbindet zwei Strings miteinander.

fun main() {
    val myString1 = "Hello,"
    val myString2 = "Mickey!"
    val combinedString = myString1.plus(" $myString2") 
    println(combinedString)     // Ergebnis: "Hello, Mickey!"
}

Anwendungsbeispiel: Ein Beispiel für die Verwendung von plus() ist die Erstellung von personalisierten Nachrichten. Wenn eine Anwendung Benutzerinformationen wie den Namen und das Alter des Benutzers hat, kann plus() verwendet werden, um eine personalisierte Nachricht zu erstellen, die diese Informationen enthält.

take(), takeLast(), drop(), dropLast()

take(), takeLast(), drop(), dropLast() gibt die ersten bzw. letzten Zeichen eines Strings zurück oder entfernt die ersten bzw. letzten n Zeichen eines Strings.

fun main() {
    val myString = "Programming with Kotlin is fun!"
    val firstThree = myString.take(3) 
    println(firstThree)    // Ergebnis: "Pro"
    val lastThree = myString.takeLast(3) 
    println(lastThree)     // Ergebnis: "un!"
    val withoutFirstThree = myString.drop(3) 
    println(withoutFirstThree)    // Ergebnis: "gramming with Kotlin is fun!"
    val withoutLastThree = myString.dropLast(3) 
    println(withoutLastThree)    // Ergebnis: "Programming with Kotlin is f"
}

Anwendungsbeispiele:

• take(): Extrahieren der ersten n Wörter aus einem Text, um eine Vorschau oder Zusammenfassung zu erstellen.
• takeLast(): Erhalten der letzten n Zeichen einer Zeichenkette, beispielsweise die letzten vier Ziffern einer Kreditkartennummer oder einer Telefonnummer, um sie teilweise zu maskieren.
• drop(): Entfernen eines Präfixes von Dateinamen oder Textstrings, um eine neue Namenskonvention anzuwenden oder unerwünschte Präfixe zu entfernen.
• dropLast(): Entfernen der Dateierweiterung eines Dateinamens, um den Basisnamen zu erhalten.

indexOf() und lastIndexOf()

indexOf() und lastIndexOf() gibt den Index des ersten bzw. letzten Vorkommens eines Zeichens oder einer Zeichenkette im String zurück. Gibt -1 zurück, wenn der Wert nicht gefunden wird. 

fun main() {
    val myString = "Hello, my dear, dear Homer!"
    val indexOfHomer = myString.indexOf("Homer")   
    println(indexOfHomer)        // Ergebnis: 21
    val lastIndexOfHomer = myString.lastIndexOf("dear")   
    println(lastIndexOfHomer)    // Ergebnis: 16
}

In diesem Codebeispiel wird die indexOf()-Funktion auf myString aufgerufen, um den ersten Index des Teilstrings ‚Homer‘ in myString zu finden. In diesem Fall liegt ‚Homer‘ am Index 21 (die Zeichenkettenindizierung beginnt bei 0).

Anschließend wird die lastIndexOf()-Funktion auf myString aufgerufen, um den letzten Index des Teilstrings ‚dear‘ in myString zu finden. Da ‚dear‘ zweimal in myString vorkommt, findet lastIndexOf() den Index des zweiten Vorkommens, das bei Index 16 liegt.

Anwendungsbeispiele:

• indexOf(): Überprüfen, ob ein Text bestimmte Schlüsselwörter oder Phrasen enthält, und deren Position finden, um den Text für die Anzeige oder Verarbeitung zu formatieren.
• lastIndexOf(): Finden des letzten Trennzeichens in einem Dateipfad oder einer URL, um den Dateinamen oder den letzten Abschnitt einer URL zu extrahieren.

isNullOrEmpty() und isNullOrBlank()

isNullOrEmpty() und isNullOrBlank() überprüft, ob ein String null oder leer bzw. null oder nur aus Leerzeichen besteht.

fun main() {
    val myString: String? = null
    val isEmptyOrNull = myString.isNullOrEmpty() 
    println(isEmptyOrNull)      // Ergebnis: true
    val isBlankOrNull = myString.isNullOrBlank() 
    println(isBlankOrNull)      // Ergebnis: true
}

In diesem Beispiel wird eine nullable String-Variable namens myString deklariert und ihr der Wert null zugewiesen. 

Die isNullOrEmpty()-Funktion wird auf myString aufgerufen. Diese Funktion überprüft, ob der übergebene String entweder null oder leer ist (d. h., keine Zeichen enthält). Da myString den Wert null hat, gibt die Funktion true zurück.

Die isNullOrBlank()-Funktion wird auf myString aufgerufen. Diese Funktion überprüft, ob der übergebene String entweder null oder nur aus Leerzeichen, Tabulatoren oder Zeilenumbrüchen besteht. Da myString den Wert null hat, gibt die Funktion ebenfalls true zurück.

Anwendungsbeispiele:

• isNullOrEmpty(): Validierung von Benutzereingaben in Formularen, um sicherzustellen, dass erforderliche Felder ausgefüllt sind und keine leeren Zeichenketten enthalten.
• isNullOrBlank(): Validierung von Benutzereingaben in Formularen, um sicherzustellen, dass erforderliche Felder nicht nur aus Leerzeichen, Tabulatoren oder Zeilenumbrüchen bestehen.

padStart() und padEnd()

Die Funktion padStart() wird verwendet, um einen String am Anfang (links) auf eine bestimmte Länge aufzufüllen. Sie hat zwei Parameter: 

• length – Die gewünschte Gesamtlänge des aufgefüllten Strings.
• padChar – Das Zeichen, mit dem der String aufgefüllt wird (optional, Standardwert ist das Leerzeichen ‚  ‚).

fun main() {
    val originalString = "Betty"
    val paddedString = originalString.padStart(10, '-')
    println(paddedString)   // Ausgabe: "----Betty"
}

In diesem Beispiel wird der String ‚Betty‘ mit Bindestrichen auf eine Gesamtlänge von 10 Zeichen gebracht.

Die Funktion padEnd() wird verwendet, um einen String am Ende (rechts) auf eine bestimmte Länge aufzufüllen. Sie hat ebenfalls zwei Parameter:

• length – Die gewünschte Gesamtlänge des aufgefüllten Strings.
• padChar – Das Zeichen, mit dem der String aufgefüllt wird (optional, Standardwert ist das Leerzeichen ‚  ‚).

fun main() {
    val originalString = "Betty"
    val paddedString = originalString.padEnd(10, '-')
    println(paddedString)    // Ausgabe: "Betty----"
}

In diesem Beispiel wird der String ‚Betty‘ mit Bindestrichen am Ende auf eine Gesamtlänge von 10 Zeichen gebracht.

Anwendungsbeispiele:

• padStart(): Formatierung von numerischen Werten, z. B. das Hinzufügen von führenden Nullen zu Zahlen, um eine gleichmäßige Anzahl von Stellen zu erreichen (z. B. für Produktcodes, Rechnungsnummern usw.).
• padEnd(): Erweitern von Zeichenketten auf eine bestimmte Länge, um die Anforderungen einer API oder einer Datenbank zu erfüllen.

reversed()

reversed() kehrt die Reihenfolge der Zeichen in einem String.

fun main() {
    val myString = "Hello, Sylvester!"
    val reversedString = myString.reversed()
    println(reversedString)    // Ergebnis: "!retsevlyS ,olleH"
}

Anwendungsbeispiel: Umkehren von Zeichenketten, um spezielle Texteffekte oder Verschlüsselungen zu erzeugen, z. B. bei der Erstellung von Rätseln oder einfachen kryptografischen Algorithmen.

repeat()

Die repeat()-Funktion wiederholt einen String n-mal.

fun main() {
    val myString = "I like Kotlin! "
    val repeatedString = myString.repeat(3) 
    println(repeatedString)    // Ergebnis: 'I like Kotlin! I like Kotlin! I like Kotlin! '
}

Anwendungsbeispiel: Wiederholung von Textelementen oder Phrasen, um künstlerische Effekte, Animationen oder Designelemente zu erzeugen.