Kotlin From Scratch: Sortimente und Kollektionen

() translation by (you can also view the original English article)

Kotlin ist eine moderne Programmiersprache, die zu Java-Bytecode kompiliert. Es ist kostenlos und Open Source und verspricht, das Programmieren für Android noch mehr Spaß zu machen.

Im vorherigen Artikel dieser Serie haben Sie die NULL-Zulässigkeit, Schleifen und Bedingungen in Kotlin kennengelernt. In diesem Tutorial lernen wir die Sprache weiter, indem wir uns die Bereiche- und Sammlungs-API in Kotlin ansehen.

1. Reichweiten

Ein Bereich in Kotlin ist ein einzigartiger Typ, der einen Startwert und einen Endwert definiert. Mit anderen Worten, es ist ein Intervall zwischen einem Start- und einem Endwert. Bereiche in Kotlin sind geschlossen, dh Startwert und Endwert sind im Bereich enthalten.

Wir werden uns nun die verschiedenen Möglichkeiten zum Erstellen von Sortimenten in Kotlin ansehen.

Der `..` Betreiber

1	val oneToFive = 1..5

Im obigen Code haben wir einen geschlossenen Bereich erstellt. Diese Variable oneToFive enthält die folgenden Werte: 1, 2, 3, 4, 5. Wir können sie mit dem for-Schleifenkonstrukt durchlaufen.

1	for (n in oneToFive) {
2	print(n)
3	}

Der obige Code kann wie folgt gekürzt werden:

1	for (n in 1..5) {
2	print(n)
3	}

Wir können auch eine Reihe von Charakteren erstellen:

1	val aToZ = "a".."z"

Die Variable aToZ enthält alle Buchstaben des englischen Alphabets.

Die `rangeTo()`-Funktion

Der Operator .. kann durch die Erweiterungsfunktion rangeTo() ersetzt werden, um einen Bereich zu erstellen. Zum Beispiel können wir dies auch mit 1.rangeTo(5) tun und es hätte immer noch die gleichen Ergebnisse wie die Verwendung des ..-Operators, wie zuvor besprochen.

1	val oneToFive: IntRange = 1.rangeTo(5)

Die `downTo()`-Funktion

Dies ist eine weitere Erweiterungsfunktion, die einen Bereich von einer bestimmten Nummer bis zu einer anderen erstellt.

1	val fiveToOne = 5.downTo(1)

Wir können den Bereich mit der Funktion step() ändern. Dadurch wird das Delta zwischen jedem Element im Bereich geändert.

1	val oneToTenStep = 1..10 step 2 // 1, 3, 5, 7, 9

Der obige Code enthält ungerade Zahlen zwischen 1 und 10.

Der `in` Operator

Der in-Operator wird verwendet, um festzustellen, ob ein Wert in einem bestimmten Bereich vorhanden ist.

1	if (5 in 1..10) {
2	print("Yes 5 is in the range") // prints "Yes 5 is in the range"
3	}

Im obigen Code haben wir mit dem in-Operator überprüft, ob 5 im Bereich 1..10 liegt. Wir können auch das Gegenteil tun, indem wir mit !n prüfen, ob 5 nicht im Bereich liegt.

2. Sammlungen

Sammlungen werden verwendet, um Gruppen zusammengehöriger Objekte im Speicher zu speichern. In einer Sammlung können wir die Objekte abrufen, aufbewahren oder organisieren. Kotlin stellt seine Sammlungs-API als Standardbibliothek bereit, die auf der Java-Sammlungs-API basiert. (Wir werden die Schnittstellen in Kotlin in einem zukünftigen Beitrag besprechen.)

Beachten Sie, dass diese Schnittstellen zur Kompilierzeit mit ihrer Implementierung verknüpft sind. Sie können den Implementierungsquellcode in Kotlin nicht sehen, da die Sammlungen tatsächlich von den Standard-Java-Sammlungen wie ArrayList, Maps, HashMap, Sets, HashSet, List usw. implementiert werden. Um die Sammlungs-API in Kotlin wirklich zu verstehen, müssen Sie mit diesen grundlegenden Klassen und Schnittstellen in Java vertraut sein.

In diesem Abschnitt lernen wir die List-, Set- und Map-Sammlungen in Kotlin kennen. (Wenn Sie eine Auffrischung zu Arrays in Kotlin wünschen, besuchen Sie bitte das erste Tutorial in dieser Serie.)

Die Sammlungen von Kotlin geben uns die Möglichkeit, mit nur wenig Code viel zu erreichen – im Gegensatz zu Java, das viel Code zu benötigen scheint, um etwas zu erreichen! Kotlin hat zwei Varianten von Kollektionen: veränderlich und unveränderlich. Eine veränderbare Sammlung bietet uns die Möglichkeit, eine Sammlung zu ändern, indem ein Element hinzugefügt, entfernt oder ersetzt wird. Unveränderliche Sammlungen können nicht geändert werden und verfügen nicht über diese Hilfsmethoden.

Beachten Sie, dass das Hinzufügen, Entfernen oder Ersetzen eines Elements in einer unveränderlichen Sammlung über Operatorfunktionen möglich ist (dazu kommen wir gleich), aber diese führen am Ende zu einer neuen Sammlung.

Die `Iterable` Schnittstelle

Die Iterable-Schnittstelle von Kotlin steht an der Spitze der Klassenhierarchie der Sammlungen. Diese Schnittstelle ermöglicht die Darstellung von Sammlungen als Folge von Elementen (die natürlich wiederholt werden können).

1	public interface Iterable<out T> {
2	public abstract operator fun iterator(): Iterator<T>
3	}

Die `Collection`-Schnittstelle

Die Schnittstelle der Kotlin Collection erweitert die Iterable-Schnittstelle. Die Collection-Schnittstelle ist unveränderlich. Mit anderen Worten, Sie haben schreibgeschützten Zugriff auf Sammlungen. Die Set- und List-Schnittstellen (mehr dazu in Kürze) in Kotlin erweitern diese Schnittstelle.

Einige der Funktionen und Eigenschaften, die in der Collection-Oberfläche verfügbar sind, sind:

size: Diese Eigenschaft gibt die Größe der Sammlung zurück.
isEmpty(): gibt true zurück, wenn die Collection leer ist, andernfalls false.
contains(element: E): gibt true zurück, wenn das im Argument angegebene Element in der Auflistung vorhanden ist.
containsAll(element: Collection<E>): gibt true zurück, wenn das als Argument übergebene Element der Collection in der Collection vorhanden ist.

public interface Collection<out E> : Iterable<E> {
    public val size: Int
    public fun isEmpty(): Boolean
    public operator fun contains(element: @UnsafeVariance E): Boolean
    override fun iterator(): Iterator<E>
    public fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
}

Die `MutableIterable`-Schnittstelle

Diese Schnittstelle in Kotlin gibt uns einen spezialisierten veränderlichen Iterator aus der übergeordneten Iterable-Schnittstelle.

1	public interface MutableIterable<out T> : Iterable<T> {
2	override fun iterator(): MutableIterator<T>
3	}

Die `MutableCollection`-Schnittstelle

Die MutableCollection-Schnittstelle in Kotlin ist eine spezialisierte Schnittstelle, die es ermöglicht, Sammlungen veränderlich zu machen. Mit anderen Worten, Operationen zum Hinzufügen und Entfernen können für eine bestimmte Sammlung ausgeführt werden. Diese Schnittstelle erweitert sowohl die Collection-Schnittstelle als auch die bereits oben besprochene MutableIterable-Schnittstelle. Die Schnittstellen MutableSet und MutableList (auf die wir gleich eingehen) in Kotlin erweitern diese Schnittstelle. Die in dieser Schnittstelle verfügbaren Funktionen – abgesehen von denen, die in den übergeordneten Funktionen verfügbar sind – sind:

add(element: E): fügt das als Argument übergebene Element der Sammlung hinzu und gibt true zurück, wenn erfolgreich oder false, wenn die Sammlung keine Duplikate unterstützt und das Element bereits vorhanden ist.
remove(element: E): entfernt das als Argument übergebene Element aus der Auflistung. Gibt true zurück, wenn erfolgreich, oder false, wenn es nicht in der Auflistung vorhanden war.
addAll(elements: Collection<E>): Fügt alle Elemente der Collection hinzu, die als Argumente an die Collection übergeben wurden. Gibt true zurück, wenn erfolgreich oder false, wenn nichts hinzugefügt wurde.
removeAll(elements: Collection<E>): entfernt alle Elemente, die in der als Argumente übergebenen Sammlung vorhanden sind. Gibt true zurück, wenn erfolgreich, oder false, wenn nichts entfernt wurde.
retainAll(elements: Collection<E>): behält nur die Elemente bei, die in den als Argumente übergebenen Sammlungen vorhanden sind. Gibt true zurück, wenn erfolgreich oder false, wenn nichts beibehalten wurde.
clear(): entfernt alle Elemente aus dieser Sammlung.

public interface MutableCollection<E> : Collection<E>, MutableIterable<E> {
    override fun iterator(): MutableIterator<E>
    public fun add(element: E): Boolean
    public fun remove(element: E): Boolean
    public fun addAll(elements: Collection<E>): Boolean
    public fun removeAll(elements: Collection<E>): Boolean
    public fun retainAll(elements: Collection<E>): Boolean
    public fun clear(): Unit
}

Nachdem Sie nun die wichtigsten Schnittstellen in der Sammlungsklassenhierarchie in Kotlin kennengelernt haben, schauen wir uns im verbleibenden Teil des Tutorials an, wie Kotlin Sammlungen wie Listen, Sets und Maps handhabt.

Listen

Eine Liste ist eine geordnete Sammlung von Elementen. Dies ist eine beliebte Sammlung, die weit verbreitet ist. Sehen wir uns verschiedene Möglichkeiten zum Erstellen einer Liste in Kotlin an.

Verwenden der `listOf()`-Funktion

In Kotlin können wir mit der Hilfsfunktion listOf() aus der Kotlin-Standardbibliothek eine unveränderliche (schreibgeschützte) Liste erstellen. Diese Funktion gibt einen Kotlin-List-Schnittstellentyp zurück.

var numbers: List<Int> = listOf(1, 2, 3, 4, 5)
var names: List<String> = listOf("Chike", "Nnamdi", "Mgbemena")
for (name in names) {
    println(name)
}

Wenn Sie den obigen Code ausführen, wird Folgendes gedruckt:

1	Chike
2	Nnamdi
3	Mgbemena

Außerdem können wir Werte verschiedener Typen als Argumente an listOf() übergeben und das Ergebnis funktioniert trotzdem – es wird eine Liste mit gemischten Typen sein.

1	var listMixedTypes = listOf("Chike", 1, 2.445, 's') // will still compile

Verwenden der Funktion `emptyList()`

Diese Funktion erstellt einfach eine leere unveränderliche Liste und gibt einen Kotlin-List-Schnittstellentyp zurück.

1	val emptyList: List<String> = emptyList<String>()

Verwenden der `listOfNotNull()`-Funktion

Diese Funktion erstellt eine neue unveränderliche Liste, die nur Elemente enthält, die nicht null sind. Beachten Sie, dass diese Funktion auch einen Kotlin-List-Schnittstellentyp zurückgibt.

1	val nonNullsList: List<String> = listOfNotNull(2, 45, 2, null, 5, null)

Die List-Schnittstelle aus der Kotlin-Standardbibliothek erweitert nur die Collection-Schnittstelle. Mit anderen Worten, ihr einziges übergeordnetes Element ist die Collection-Schnittstelle. Es überschreibt alle Funktionen in der übergeordneten Schnittstelle, um seinen speziellen Anforderungen gerecht zu werden, und definiert auch seine eigenen Funktionen, wie zum Beispiel:

get(index: Int): ein Funktionsoperator, der das Element am angegebenen Index zurückgibt.
indexOf(element: E): gibt den Index des ersten Vorkommens des als Argument in der Liste übergebenen Elements zurück, oder -1, wenn keines gefunden wird.
lastIndexOf(element: E): gibt den Index des letzten Vorkommens des als Argument in der Liste übergebenen Elements zurück, oder -1, wenn keines gefunden wird.
listIterator(): gibt einen Listeniterator über die Elemente in der Liste zurück.
subList(fromIndex: Int, toIndex: Int): Gibt eine Liste zurück, die den Teil der Liste zwischen den angegebenen Start- und Endindizes enthält.

1	println(names.size) // 3
2	println(names.get(0)) // "Chike"
3	println(names.indexOf("Mgbemena")) // 2
4	println(names.contains("Nnamdi")) // 'true'

Verwenden der `arrayListOf()`-Funktion

Dadurch wird eine veränderbare Liste erstellt und ein Java-ArrayList-Typ zurückgegeben.

1	val stringList: ArrayList<String> = arrayListOf<String>("Hello", "You", "There")

Verwenden der `mutableListOf()`-Funktion

Um Werte in einer Liste hinzuzufügen, zu entfernen oder zu ersetzen, müssen wir die Liste veränderbar machen. Wir können eine unveränderliche Liste in eine veränderliche umwandeln, indem wir die Funktion toMutableList() für die Liste aufrufen. Beachten Sie jedoch, dass diese Methode eine neue Liste erstellt.

1	var mutableNames1 = names.toMutableList()
2	mutableNames1.add("Ruth") // now mutable and added "Ruth" to list

Um eine veränderliche Liste eines bestimmten Typs von Grund auf neu zu erstellen, z.B. String verwenden wir mutableListOf<String>(), während wir für gemischte Typen stattdessen einfach die mutableListOf()-Funktion verwenden können.

// a mutable list of a certain type e.g. String
val mutableListNames: MutableList<String> = mutableListOf<String>("Josh", "Kene", "Sanya")
mutableListNames.add("Mary")
mutableListNames.removeAt(1) 
mutableListNames[0] = "Oluchi" // replaces the element in index 0 with "Oluchi"

// a mutable list of mixed types
val mutableListMixed = mutableListOf("BMW", "Toyota", 1, 6.76, 'v')

Jede dieser Funktionen gibt einen MutableList-Kotlin-Schnittstellentyp zurück. Diese Schnittstelle erweitert sowohl die MutableCollection- als auch die List-Schnittstelle, die weiter oben in diesem Abschnitt besprochen wurde. Die MutableList-Schnittstelle fügt Methoden zum Abrufen oder Ersetzen eines Elements basierend auf seiner Position hinzu:

set(index: Int, element: E): ersetzt ein Element in der Liste durch ein anderes Element. Dadurch wird das Element zuvor an der angegebenen Position zurückgegeben.
add(index: Int, element: E): fügt ein Element am angegebenen Index ein.
removeAt(index: Int): entfernt das Element an einem bestimmten Index.

val mutableListFood: MutableList<String> = mutableListOf<String>("Rice & stew", "Jollof rice", "Eba & Egusi", "Fried rice")
mutableListFood.remove("Fried rice")
mutableListFood.removeAt(0)
mutableListFood.set(0, "Beans")
mutableListFood.add(1, "Bread & tea")

for (foodName in mutableListFood) {
    println(foodName)
}

Wenn wir den obigen Code ausführen, erhalten wir das folgende Ergebnis:

1	Beans
2	Bread & tea
3	Eba & Egusi

Beachten Sie, dass alle diese Funktionen hinter den Kulissen eine Java ArrayList erstellen.

Sätze

Ein Set ist eine ungeordnete Sammlung einzigartiger Elemente. Mit anderen Worten, es darf keine Duplikate enthalten! Sehen wir uns einige der verschiedenen Möglichkeiten zum Erstellen eines Sets in Kotlin an. Jede davon erzeugt eine andere Datenstruktur, die jeweils für eine bestimmte Art von Aufgabe optimiert ist.

Verwenden der `setOf()`-Funktion

Um ein unveränderliches (schreibgeschütztes) Set in Kotlin zu erstellen, können wir die Funktion setOf() verwenden, die einen Kotlin-Set-Schnittstellentyp zurückgibt.

1	// creates a immutable set of mixed types
2	val mixedTypesSet = setOf(2, 4.454, "how", "far", 'c') // will compile
3
4	var intSet: Set<Int> = setOf(1, 3, 4) // only integers types allowed

Beachten Sie, dass die Kotlin-Set-Schnittstelle nur die Kotlin-Collection-Schnittstelle erweitert und alle in ihrem übergeordneten Element verfügbaren Eigenschaften überschreibt.

Verwenden der `hashSetOf()`-Funktion

Mit der Funktion hashSetOf() wird eine Java-HashSet-Sammlung erstellt, die Elemente in einer Hash-Tabelle speichert. Da diese Funktion einen Java-HashSet-Typ zurückgibt, können wir Elemente im Set hinzufügen, entfernen oder löschen. Mit anderen Worten, es ist veränderlich.

1	val intsHashSet: java.util.HashSet<Int> = hashSetOf(1, 2, 6, 3)
2	intsHashSet.add(5)
3	intsHashSet.remove(1)

Verwenden der Funktion `sortedSetOf()`

Mit der Funktion sortedSetOf() wird im Hintergrund eine Java-TreeSet-Sammlung erstellt, die Elemente basierend auf ihrer natürlichen Reihenfolge oder durch einen Komparator ordnet. Dieses Set ist auch veränderbar.

1	val intsSortedSet: java.util.TreeSet<Int> = sortedSetOf(4, 1, 7, 2)
2	intsSortedSet.add(6)
3	intsSortedSet.remove(1)
4	intsSortedSet.clear()

Verwenden der Funktion `linkedSetOf()`

Diese Funktion gibt einen Java LinkedHashSet-Typ zurück. Dieser veränderliche Satz verwaltet eine verknüpfte Liste der Einträge im Satz in der Reihenfolge, in der sie eingefügt wurden.

1	val intsLinkedHashSet: java.util.LinkedHashSet<Int> = linkedSetOf(5, 2, 7, 2, 5) // 5, 2, 7
2	intsLinkedHashSet.add(4)
3	intsLinkedHashSet.remove(2)
4	intsLinkedHashSet.clear()

Verwenden der `mutableSetOf()`-Funktion

Wir können mutableSetOf() verwenden, um eine veränderliche Menge zu erstellen. Diese Funktion gibt einen Kotlin MutableSet-Schnittstellentyp zurück. Hinter den Kulissen erstellt diese Funktion einfach ein Java LinkedHashSet.

1	// creates a mutable set of int types only
2	val intsMutableSet: MutableSet<Int> = mutableSetOf(3, 5, 6, 2, 0)
3	intsMutableSet.add(8)
4	intsMutableSet.remove(3)

Die MutableSet-Schnittstelle erweitert sowohl die MutableCollection- als auch die Set-Schnittstelle.

Karten

Maps ordnen Schlüssel Werten zu. Die Schlüssel müssen eindeutig sein, die zugehörigen Werte jedoch nicht. Auf diese Weise kann jeder Schlüssel verwendet werden, um den zugehörigen Wert eindeutig zu identifizieren, da die Zuordnung sicherstellt, dass Sie keine doppelten Schlüssel in der Sammlung haben können. Hinter den Kulissen verwendet Kotlin die Java Map-Sammlung, um seinen Kartensammlungstyp zu implementieren.

Verwenden der `mapOf()`-Funktion

Um eine unveränderliche oder schreibgeschützte Map-Sammlung in Kotlin zu erstellen, verwenden wir die Funktion mapOf(). Wir erstellen mit dieser Funktion eine Karte, indem wir ihr eine Liste von Paaren geben – der erste Wert ist der Schlüssel und der zweite der Wert. Der Aufruf dieser Funktion gibt einen Kotlin-Map-Schnittstellentyp zurück.

val callingCodesMap: Map<Int, String> = mapOf(234 to "Nigeria", 1 to "USA", 233 to "Ghana")
for ((key, value) in callingCodesMap) {
    println("$key is the calling code for $value")
}
print(callingCodesMap[234]) // Nigeria

Wenn Sie den obigen Code ausführen, erhalten Sie das Ergebnis:

1	234 is the calling code for Nigeria
2	1 is the calling code for USA
3	233 is the calling code for Ghana

Im Gegensatz zu den List- und Set-Schnittstellen in Kotlin, die die Collection-Schnittstelle erweitern, erweitert die Map-Schnittstelle überhaupt keine. Einige der in dieser Schnittstelle verfügbaren Eigenschaften und Funktionen sind:

size: Diese Eigenschaft gibt die Größe der Kartensammlung zurück.
isEmpty(): gibt true zurück, wenn die Map leer ist, andernfalls false.
containsKey(key: K): gibt true zurück, wenn die Map den Schlüssel im Argument enthält.
containsValue(value: V): gibt true zurück, wenn die Map dem als Argument übergebenen Wert einen oder mehrere Schlüssel zuordnet.
get(key: K): gibt den Wert zurück, der dem angegebenen Schlüssel entspricht, oder 'null', wenn keiner gefunden wird.
keys: Diese Eigenschaft gibt einen unveränderlichen Sets aller Schlüssel in der Karte zurück.
values: gibt eine unveränderliche Collection aller Werte in der Karte zurück.

Verwenden der `mutableMapOf()`-Funktion

Die Funktion mutableMapOf() erstellt für uns eine veränderliche Karte, damit wir Elemente in der Karte hinzufügen und entfernen können. Dies gibt einen Kotlin MutableMap-Schnittstellentyp zurück.

val currenciesMutableMap: MutableMap<String, String> = mutableMapOf("Naira" to "Nigeria", "Dollars" to "USA", "Pounds" to "UK")
println("Countries are ${currenciesMutableMap.values}") // Countries are [Nigeria, USA, UK]
println("Currencies are ${currenciesMutableMap.keys}") // Currencies are [Naira, Dollars, Pounds]
currenciesMutableMap.put("Cedi", "Ghana")
currenciesMutableMap.remove("Dollars")

Die MutableMap-Schnittstelle erweitert die MutableCollection-Schnittstelle nicht. Das einzige übergeordnete Element ist die Map-Schnittstelle. Es überschreibt die Eigenschaften von keys, entries und values der übergeordneten Schnittstelle, um sie neu zu definieren. Hier sind einige der zusätzlichen Funktionen, die in der MutableMap-Schnittstelle verfügbar sind:

put(key: K, value: V): fügt das Schlüssel-Wert-Paar in die Map ein. Dies gibt den vorherigen Wert zurück, der mit dem Schlüssel verknüpft ist, oder null, wenn der Schlüssel zuvor nicht verwendet wurde.
remove(key: K): entfernt den Schlüssel und seinen verknüpften Wert aus der Map.
putAll(from: Map<out K, V>): aktualisiert die Karte mit allen Daten aus der angegebenen Karte. Neue Schlüssel werden hinzugefügt und vorhandene Schlüssel werden mit neuen Werten aktualisiert.
clear(): entfernt alle Elemente aus der Map.

Wir können den Wert für einen Schlüssel mit der Funktion get() abrufen. Wir können auch die Notation in eckigen Klammern als Abkürzung für get() verwenden.

1	print(currenciesMutableMap.get("Nigeria")) // will print Naira
2	print(currenciesMutableMap["Nigeria"]) // will print Naira

Verwenden der `hashMapOf()`-Funktion

Die Verwendung dieser Funktion gibt einen veränderlichen Java-HashMap-Typ zurück. Die HashMap-Klasse verwendet eine Hash-Tabelle, um die Java-Map-Schnittstelle zu implementieren.

1	val personsHashMap: java.util.HashMap<Int, String> = hashMapOf(1 to "Chike", 2 to "John", 3 to "Emeka")
2	personsHashMap.put(4, "Chuka")
3	personsHashMap.remove(2)
4	print(personsHashMap[1]) // will print Chike

Verwenden der `linkedHashMap()`-Funktion

Diese Funktion gibt einen veränderlichen Java LinkedHashMap-Typ zurück. Die Klasse LinkedHashMap erweitert Java HashMap und verwaltet eine verknüpfte Liste der Einträge in der Karte in der Reihenfolge, in der sie eingefügt wurden.

val postalCodesHashMap: java.util.LinkedHashMap<String, String> =
linkedMapOf("NG" to "Nigeria","AU" to "Australia","CA" to "Canada")
postalCodesHashMap.put("NA", "Namibia")
postalCodesHashMap.remove("AU")
postalCodesHashMap.get("CA") // Canada

Verwenden der Funktion `sortedMapOf()`

Diese Funktion gibt einen veränderlichen Java SortedMap-Typ zurück. Die Java SortedMap-Klasse sieht, dass die Einträge in der Map in aufsteigender Schlüsselreihenfolge verwaltet werden.

1	val personsSortedMap: java.util.SortedMap<Int, String> = sortedMapOf(2 to "Chike", 1 to "John", 3 to "Emeka")
2	personsSortedMap.put(7, "Adam")
3	personsSortedMap.remove(3)

Denken Sie daran, dass die Implementierung dieser Sammlungsschnittstellen in Kotlin zur Kompilierzeit erfolgt.

Funktionen für Sammlungen

Kotlin stellt uns viele nützliche Operatorfunktionen zur Verfügung, die als Erweiterungsfunktionen bezeichnet werden und auf Sammlungen aufgerufen werden können. Werfen wir einen Blick auf einige der nützlichsten.

Die `last()`-Funktion

Diese Operatorfunktion gibt das letzte Element in einer Sammlung wie einer Liste oder Menge zurück. Wir können auch ein Prädikat angeben, um innerhalb einer Teilmenge von Elementen zu suchen.

val stringList: List<String> = listOf("in", "the", "club")
print(stringList.last()) // will print "club"

// given a predicate
print(stringList.last{ it.length == 3}) // will print "the"

val intSet: Set<Int> = setOf(3, 5, 6, 6, 6, 3)
print(intSet.last()) // will print 6

Die `first()` Funktion

Diese Operatorfunktion gibt das erste Element zurück, wenn sie für eine Sammlung wie eine Liste oder Menge aufgerufen wird. Wenn ein Prädikat angegeben ist, verwendet es das Prädikat, um die Operation auf eine Teilmenge von Elementen zu beschränken.

1	print(stringList.first()) // will print "in"
2	print(intSet.first()) // will print 3

Die `max()`-Funktion

Das Aufrufen dieser Operatorfunktion für eine Sammlung wie eine Liste oder ein Set gibt das größte Element zurück oder null, wenn kein größtes Element gefunden wird.

1	val intList: List<Int> = listOf(1, 3, 4)
2	print(intList.max()) // will print 4
3	print(intSet.max()) // will print 6

Die `drop()`-Funktion

Der Aufruf dieser Operatorfunktion gibt eine neue Liste oder Menge zurück, die alle Elemente außer den ersten n Elementen enthält.

1	print(stringList.drop(2)) // will print "club"

Die `plus()`-Funktion

Diese Operatorfunktion gibt eine Sammlung zurück, die alle Elemente des Originals enthält und dann das angegebene Element, wenn es nicht bereits in der Sammlung enthalten ist. Dadurch wird am Ende eine neue Liste erstellt, anstatt die Liste zu ändern.

1	print(intList.plus(6)) // will print [1, 3, 4, 6]

Die `minus()`-Funktion

Das Gegenteil der Funktion plus() ist die Funktion minus(). Es gibt eine Sammlung zurück, die alle Elemente der ursprünglichen Menge außer dem angegebenen Element enthält. Dies führt auch dazu, dass eine neue Liste erstellt wird, anstatt die Liste zu ändern.

1	print(intList.minus(3)) // will print [1, 4]

Die `average()`-Funktion

Der Aufruf dieser Operatorfunktion gibt eine durchschnittliche Anzahl von Elementen in der Sammlung zurück.

1	print(intList.average()) // will print 2.6666666666666665

Die meisten dieser Erweiterungsfunktionen sind in der Standardbibliothek der Kotlin-Sammlungen verfügbar. Es wird empfohlen, die Dokumentation zu lesen, um mehr über die anderen zu erfahren.

Abschluss

In diesem Tutorial haben Sie die Bereichs- und Sammlungs-API in der Programmiersprache Kotlin kennengelernt. Im nächsten Tutorial der Kotlin From Scratch-Reihe werden Sie in die Funktionen von Kotlin eingeführt. Seh dich später!

Um mehr über die Kotlin-Sprache zu erfahren, empfehle ich den Besuch der Kotlin-Dokumentation. Oder sieh dir einige unserer anderen Beiträge zur Entwicklung von Android-Apps hier auf Envato Tuts an!

Kotlin From Scratch: Sortimente und Kollektionen

1. Reichweiten

Der .. Betreiber

Die rangeTo()-Funktion

Die downTo()-Funktion

Der in Operator

2. Sammlungen

Die Iterable Schnittstelle

Die Collection-Schnittstelle

Die MutableIterable-Schnittstelle

Die MutableCollection-Schnittstelle

Listen

Verwenden der listOf()-Funktion

Verwenden der Funktion emptyList()

Verwenden der listOfNotNull()-Funktion

Verwenden der arrayListOf()-Funktion

Verwenden der mutableListOf()-Funktion

Sätze

Verwenden der setOf()-Funktion

Verwenden der hashSetOf()-Funktion

Verwenden der Funktion sortedSetOf()

Verwenden der Funktion linkedSetOf()

Verwenden der mutableSetOf()-Funktion