Kotlin From Scratch Bereiche und Sammlungen

Kotlin ist eine moderne Programmiersprache, die Java-Bytecode kompiliert. Es ist kostenlos und Open Source und verspricht, die Kodierung für Android noch mehr Spaß zu machen.

In dem vorherigen Artikel dieser Serie haben Sie die Nullfähigkeit, Schleifen und Bedingungen in Kotlin kennen gelernt. In diesem Lernprogramm lernen wir die Sprache weiter, indem wir uns die APIs für Bereiche und Sammlungen in Kotlin ansehen.

1. Bereiche

Ein Bereich in Kotlin ist ein eindeutiger 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, das heißt, der Startwert und der Endwert sind im Bereich enthalten. 

Wir werden uns jetzt die verschiedenen Arten ansehen, wie Sie in Kotlin Sortimente erstellen können.

Das …  Operator

val oneToFive = 1… 5

Im obigen Code haben wir einen geschlossenen Bereich erstellt. Diese Variable oneToFive enthält die folgenden Werte: 1, 2, 3, 4, 5. Wir können es mit dem Loop durchlaufen zum Schleifenkonstrukt.

für (n in oneToFive) print (n)

Der obige Code kann abgekürzt werden zu:

für (n in 1… 5) print (n)

Wir können auch eine Reihe von Zeichen erstellen:

val aToZ = "a"… "z"

Die Variable A bis Z wird alle Buchstaben im englischen Alphabet haben.

Das rangeTo () Funktion

Das … Operator kann durch den ersetzt werden rangeTo () Erweiterungsfunktion zum Erstellen eines Bereichs. Zum Beispiel können wir das auch tun 1. BereichTo (5) und es hätte immer noch die gleichen Ergebnisse wie bei der Verwendung von …  Betreiber wie zuvor erläutert. 

val oneToFive: IntRange = 1.rangeTo (5)

Das bis zu() Funktion

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

val fiveToOne = 5.downTo (1)

Wir können den Bereich mit ändern Schritt() Funktion. Dadurch wird das Delta zwischen jedem Element im Bereich geändert.

val oneToTenStep = 1… 10 Schritt 2 // 1, 3, 5, 7, 9

Der obige Code enthält ungerade Zahlen zwischen 1 und 10.

Das im Operator

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

if (5 in 1… 10) print ("Ja 5 ist im Bereich") // druckt "Ja 5 ist im Bereich"

Im obigen Code haben wir überprüft, ob 5 im Bereich von 1 bis 10 liegt im Operator. Wir können auch das Gegenteil tun !n um zu prüfen, ob 5 nicht im Bereich liegt.

2. Sammlungen

Sammlungen werden verwendet, um Gruppen zusammengehöriger Objekte im Speicher abzulegen. In einer Sammlung können wir die Objekte abrufen, speichern oder organisieren. Kotlin bietet seine Collections-API als Standardbibliothek an, die auf der Java-Collections-API basiert. (In Kotlin werden wir in einem zukünftigen Beitrag Schnittstellen besprechen.) 

Sie sollten beachten, dass diese Schnittstellen zur Kompilierzeit mit ihrer Implementierung verknüpft sind. Sie können den Implementierungsquellcode in Kotlin nicht sehen, da die Sammlungen tatsächlich von den Standard-Java-Sammlungen wie z. B. implementiert werden Anordnungsliste, Karten, HashMap, Sets, HashSet, Liste und so weiter. Um die Collections-API in Kotlin wirklich zu verstehen, müssen Sie mit diesen grundlegenden Klassen und Schnittstellen in Java vertraut sein.

In diesem Abschnitt erfahren Sie mehr über die Liste, einstellen und Karte Sammlungen in Kotlin. (Wenn Sie eine Auffrischung der Arrays in Kotlin wünschen, besuchen Sie bitte das erste Tutorial dieser Serie.) 

Kotlins Kollektionen geben uns die Möglichkeit, mit wenig Code viel zu erreichen - im Gegensatz zu Java, das scheinbar sehr viel Code braucht, um ein wenig zu erreichen! Kotlin hat zwei Varianten von Sammlungen: veränderlich und unveränderlich. Eine veränderliche Auflistung ermöglicht es uns, eine Auflistung zu ändern, indem ein Element hinzugefügt, entfernt oder ersetzt wird. Unveränderbare Sammlungen können nicht geändert werden und verfügen nicht über diese Hilfsmethoden. 

Beachten Sie, dass das Hinzufügen, Entfernen oder Ersetzen eines Elements in einer unveränderlichen Auflistung über Operatorfunktionen möglich ist (wir werden das in Kürze tun), aber diese erstellen am Ende eine neue Auflistung.

Das Iterable Schnittstelle

Der Kotlin Iterable Die Benutzeroberfläche befindet sich oben in der Hierarchie der Sammlungen. Diese Schnittstelle ermöglicht die Darstellung von Sammlungen als Folge von Elementen (die natürlich wiederholt werden können).. 

öffentliche Schnittstelle Iterable public abstract operator fun iterator (): Iterator 

Das Sammlung Schnittstelle

Der Kotlin Sammlung Schnittstelle erweitert die Iterable Schnittstelle. Das Sammlung Schnittstelle ist unveränderlich. Mit anderen Worten, Sie haben Lesezugriff auf Sammlungen. Das einstellen und Liste Schnittstellen (mehr dazu in Kürze) in Kotlin erweitern diese Schnittstelle. 

Einige der Funktionen und Eigenschaften, die in verfügbar sind Sammlung Schnittstelle sind:

• Größe: Diese Eigenschaft gibt die Größe der Sammlung zurück.
• ist leer(): gibt true zurück, wenn die Sammlung leer ist oder andernfalls false. 
• enthält (Element: E): Gibt true zurück, wenn das im Argument angegebene Element in der Auflistung vorhanden ist.
• enthältAll (Element: Collection): Gibt true zurück, wenn das als Argument übergebene Element in der Auflistung in der Auflistung vorhanden ist.  

öffentliche Schnittstelle Collection : Iterierbar public val size: Int public fun isEmpty (): Der boolesche öffentliche Operator fun enthält (Element: @UnsafeVariance E): Boolean überschreibt den iterator (): Iterator öffentlicher Spaß enthältAll (Elemente: Sammlung<@UnsafeVariance E>): Boolean

Das MutableIterable Schnittstelle

Diese Schnittstelle in Kotlin gibt uns einen spezialisierten mutierbaren Iterator vom übergeordneten Element Iterable Schnittstelle.

öffentliche Schnittstelle MutableIterable : Iterierbar iterator überschreiben (): MutableIterator 

Das MutableCollection Schnittstelle

Das MutableCollection Die Schnittstelle in Kotlin ist eine spezialisierte Schnittstelle, mit der Sammlungen veränderbar werden können. Mit anderen Worten, das Hinzufügen und Entfernen von Operationen kann für eine bestimmte Sammlung ausgeführt werden. Diese Schnittstelle erweitert sowohl die Sammlung Schnittstelle und die MutableIterable Schnittstelle bereits oben diskutiert. Das MutableSet und MutableList Schnittstellen (wir werden sie in Kürze erhalten) in Kotlin erweitern diese Schnittstelle. Die Funktionen, die in dieser Benutzeroberfläche zur Verfügung stehen, sind:

• add (Element: E): fügt das als Argument übergebene Element der Auflistung hinzu und gibt true zurück, wenn erfolgreich, oder false, wenn die Auflistung keine Duplikate unterstützt und das Element bereits vorhanden ist.
  
• entfernen (Element: E): entfernt das als Argument übergebene Element aus der Auflistung. Gibt true zurück, wenn erfolgreich, oder false, wenn es nicht in der Auflistung vorhanden war.
• addAll (Elemente: Sammlung): fügt alle Elemente in der Auflistung der Auflistung als Argumente hinzu. Gibt true zurück, wenn erfolgreich, oder false, wenn nichts hinzugefügt wurde.
• removeAll (Elemente: Sammlung): Entfernt alle Elemente der Sammlung, die als Argumente übergeben werden. Gibt true zurück, wenn erfolgreich, oder false, wenn nichts entfernt wurde.
  
• keepAll (Elemente: Sammlung): behält nur die Elemente in den Sammlungen bei, die als Argumente übergeben werden. Gibt true zurück, wenn erfolgreich, oder false, wenn nichts beibehalten wurde. 
  
• klar(): Entfernt alle Elemente aus dieser Sammlung.

öffentliche Schnittstelle MutableCollection : Sammlung, MutableIterable iterator überschreiben (): MutableIterator öffentlicher Spaß add (Element: E): Boolescher öffentlicher Spaß entfernen (Element: E): Boolescher öffentlicher Spaß addAll (Elemente: Collection): Boolescher öffentlicher Spaß removeAll (Elemente: Collection): Boolescher öffentlicher SpaßkäfigAll (Elemente: Collection): Boolescher öffentlicher Spaß clear (): Unit

Jetzt haben Sie die wichtigsten Schnittstellen in der Collection-Klassenhierarchie in Kotlin kennen gelernt. Lassen Sie uns nun untersuchen, wie Kotlin im verbleibenden Teil des Lernprogramms mit Sammlungen wie Listen, Sets und Maps umgeht.

Listen

Eine Liste ist eine geordnete Sammlung von Elementen. Dies ist eine beliebte Sammlung, die weit verbreitet ist. Lassen Sie uns verschiedene Möglichkeiten zum Erstellen einer Liste in Kotlin betrachten.

Verwendung der Liste von() Funktion

In Kotlin können Sie eine unveränderliche (schreibgeschützte) Liste erstellen, indem Sie die Liste von() Hilfsfunktion aus der Kotlin-Standardbibliothek. Diese Funktion gibt einen Kotlin zurück Liste Oberflächentyp.

Var-Nummern: Liste = listOf (1, 2, 3, 4, 5) Variablennamen: Liste = listOf ("Chike", "Nnamdi", "Mgbemena") für (Name in Namen) println (Name)

Das Ausführen des obigen Codes wird gedruckt: 

Chike Nnamdi Mgbemena

Darüber hinaus können wir Werte verschiedener Typen in die übergeben Liste von() als Argumente und das Ergebnis wird immer noch funktionieren - es wird eine Liste von gemischten Typen sein. 

var listMixedTypes = listOf ("Chike", 1, 2.445, 's') // wird immer noch kompiliert 

Verwendung der leere Liste() Funktion

Diese Funktion erstellt nur eine leere unveränderliche Liste und gibt einen Kotlin zurück Liste Oberflächentyp.

val emptyList: Liste = leereListe() 

Verwendung der listOfNotNull () Funktion

Diese Funktion erstellt eine neue unveränderliche Liste, die nur Elemente enthält, die nicht null sind. Beachten Sie, dass diese Funktion einen Kotlin zurückgibt Liste Schnittstellentyp auch.

val nonNullsList: Liste = listOfNotNull (2, 45, 2, null, 5, null)

Das Liste Schnittstelle aus der Kotlin Standardbibliothek erweitert nur die Sammlung Schnittstelle. Mit anderen Worten, das einzige übergeordnete Element ist das Sammlung Schnittstelle. Es überschreibt alle Funktionen in der übergeordneten Schnittstelle, um auf seine speziellen Bedürfnisse einzugehen, und definiert auch seine eigenen Funktionen, z.

• get (Index: Int): Ein Funktionsoperator, der das Element am angegebenen Index zurückgibt. 
• indexOf (Element: E): Gibt den Index des ersten Vorkommens des Elements zurück, das als Argument in der Liste übergeben wird, oder -1, wenn keines gefunden wird.
  
• lastIndexOf (Element: E): Gibt den Index des letzten Vorkommens des Elements zurück, das als Argument in der Liste übergeben wurde, oder -1, wenn keines gefunden wird. 
• listIterator (): gibt einen Listen-Iterator über die Elemente in der Liste zurück.
• subList (fromIndex: Int, bisIndex: Int): gibt eine Liste zurück, die den Teil der Liste zwischen den angegebenen Start- und Endindizes enthält. 

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

Verwendung der arrayListOf () Funktion

Dadurch wird eine veränderliche Liste erstellt und Java zurückgegeben Anordnungsliste Art.

val stringList: ArrayList = arrayListOf("Hallo Du da") 

Verwendung der mutableListOf () Funktion

Um Werte in einer Liste hinzufügen, entfernen oder ersetzen zu können, müssen wir die Liste in einen veränderlichen Wert umwandeln. Wir können eine unveränderliche Liste in eine veränderliche umwandeln, indem Sie die Funktion aufrufen toMutableList () auf der Liste. Beachten Sie jedoch, dass diese Methode eine neue Liste erstellt.

var mutableNames1 = names.toMutableList () mutableNames1.add ("Ruth") // jetzt mutierbar und fügte "Ruth" zur Liste hinzu

Um eine veränderliche Liste eines bestimmten Typs von Grund auf zu erstellen, z. String, wir gebrauchen mutableListOf(), für gemischte Typen können wir einfach die mutableListOf () Funktion stattdessen.

// eine veränderliche Liste eines bestimmten Typs, z. String val mutableListNames: MutableList = mutableListOf("Josh", "Kene", "Sanya") mutableListNames.add ("Mary") mutableListNames.removeAt (1) mutableListNames [0] = "Oluchi" // Ersetzt das Element in Index 0 durch "Oluchi" // a mutierbare Liste gemischter Typen val mutableListMixed = mutableListOf ("BMW", "Toyota", 1, 6.76, 'v')

Jede dieser Funktionen gibt a zurück MutableList Kotlin-Schnittstellentyp. Diese Schnittstelle erweitert sowohl die MutableCollection und Liste Schnittstellen, die zuvor in diesem Abschnitt beschrieben wurden. Das MutableList Das Interface fü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. Dies gibt das Element an der angegebenen Position zurück.
  
• add (Index: Int, Element: E): fügt ein Element am angegebenen Index ein. 
• removeAt (Index: Int): Entfernt das Element an einem bestimmten Index. 

val mutableListFood: MutableList = mutableListOf("Reis & Eintopf", "Jollof-Reis", "Eba & Egusi", "Gebratener Reis") mutableListFood.remove ("Fried rice") mutableListFood.removeAt (0) mutableListFood.set (0, "Beans") mutableListFood. add (1, "Bread & tea") für (foodName in mutableListFood) println (foodName)

Mit dem obigen Code erzeugen wir folgendes Ergebnis:

Bohnen Brot & Tee Eba & Egusi

Beachten Sie, dass alle diese Funktionen ein Java erstellen Anordnungsliste hinter den Kulissen.

Sets

Ein Set ist eine ungeordnete Sammlung eindeutiger Elemente. Mit anderen Worten, es darf keine Duplikate haben! Sehen wir uns einige Möglichkeiten an, wie Sie in Kotlin ein Set erstellen können. Jede davon erzeugt eine andere Datenstruktur, die jeweils für eine bestimmte Aufgabe optimiert ist. 

Verwendung der setOf () Funktion

Um eine unveränderliche (schreibgeschützte) Menge in Kotlin zu erstellen, können Sie die Funktion verwenden setOf (), was einen Kotlin zurückgibt einstellen Oberflächentyp. 

// erstellt einen unveränderlichen Satz gemischter Typen. val mixedTypesSet = setOf (2, 4.454, "how", "far", 'c') // wird var intSet: Set kompilieren = setOf (1, 3, 4) // Nur ganzzahlige Typen zulässig

Beachten Sie, dass der Kotlin einstellen Schnittstelle erweitert nur den Kotlin Sammlung Schnittstelle und überschreibt alle Eigenschaften, die in seinem übergeordneten Element verfügbar sind.

Verwendung der hashSetOf () Funktion 

Verwendung der hashSetOf () Funktion erstellt ein Java HashSet Sammlung, die Elemente in einer Hashtabelle speichert. Weil diese Funktion Java zurückgibt HashSet Wenn Sie den Typ eingeben, können wir Elemente hinzufügen, entfernen oder löschen. Mit anderen Worten, es ist veränderlich. 

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

Verwendung der sortiertesSetOf () Funktion

Verwendung der sortiertesSetOf () Funktion erstellt ein Java TreeSet Sammlung hinter den Kulissen, die Elemente nach ihrer natürlichen Anordnung oder nach einem Vergleicher anordnet. Dieser Satz ist auch veränderbar.

val intsSortedSet: java.util.TreeSet =ortedSetOf (4, 1, 7, 2) intsSortedSet.add (6) intsSortedSet.remove (1) intsSortedSet.clear ()

Verwendung der linkedSetOf () Funktion

Diese Funktion gibt ein Java zurück LinkedHashSet Art. Dieses veränderliche Set enthält eine verknüpfte Liste der Einträge des Sets in der Reihenfolge, in der sie eingefügt wurden. 

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

Verwendung der mutableSetOf () Funktion

Wir können benutzen mutableSetOf () einen veränderbaren Satz erstellen. Diese Funktion gibt einen Kotlin zurück MutableSet Oberflächentyp. Hinter den Kulissen erstellt diese Funktion lediglich ein Java LinkedHashSet.  

// erstellt eine veränderliche Menge von Int-Typen, die nur inTMMutableSet: MutableSet enthalten sind = mutableSetOf (3, 5, 6, 2, 0) intsMutableSet.add (8) intsMutableSet.remove (3)

Das MutableSet Schnittstelle erweitert sowohl die MutableCollection und das einstellen Schnittstellen. 

Karten

Zuordnungen von Schlüsseln zu Werten. Die Schlüssel müssen eindeutig sein, die zugehörigen Werte müssen jedoch nicht sein. Auf diese Weise kann jeder Schlüssel verwendet werden, um den zugehörigen Wert eindeutig zu identifizieren, da durch die Zuordnung sichergestellt wird, dass in der Sammlung keine doppelten Schlüssel vorhanden sind. Hinter den Kulissen verwendet Kotlin Java Karte Sammlung, um den Typ der Kartensammlung zu implementieren.

Verwendung der Karte von() Funktion

So erstellen Sie eine unveränderliche Datei oder schreibgeschützt Karte Sammlung in Kotlin verwenden wir die Karte von() Funktion. Wir erstellen eine Map mit dieser Funktion, indem wir ihr eine Liste von Paaren geben. Der erste Wert ist der Schlüssel und der zweite ist der Wert. Beim Aufruf dieser Funktion wird ein Kotlin zurückgegeben Karte Oberflächentyp.

val callingCodesMap: Karte = mapOf (234 für "Nigeria", 1 für "USA", 233 für "Ghana") für ((Schlüssel, Wert) in callCodesMap) println ("$ key ist der Aufrufcode für $ value") print (callingCodesMap.) [234]) // Nigeria

Wenn Sie den obigen Code ausführen, erhalten Sie das Ergebnis: 

234 ist die Vorwahl von Nigeria 1 ist die Vorwahl von USA 233 ist die Vorwahl von Ghana

Nicht so wie Liste und einstellen Schnittstellen in Kotlin, die das erweitern Sammlung Schnittstelle, die Karte Schnittstelle erstreckt sich überhaupt nicht. Einige der Eigenschaften und Funktionen dieser Schnittstelle sind:

• Größe: Diese Eigenschaft gibt die Größe der Kartensammlung zurück.
• ist leer(): gibt true zurück, wenn die Map leer ist oder andernfalls false.
• containsKey (Schlüssel: K): gibt true zurück, wenn die Karte den Schlüssel im Argument enthält. 
• containsValue (Wert: V): gibt true zurück, wenn die Karte einen oder mehrere Schlüssel dem als Argument übergebenen Wert zuordnet.
• erhalten (Schlüssel: K): gibt den Wert zurück, der dem angegebenen Schlüssel entspricht, oder 'null', wenn keiner gefunden wird. 
• Schlüssel: Diese Eigenschaft gibt eine unveränderliche Datei zurück einstellen aller Schlüssel in der Karte.
• Werte: gibt eine unveränderliche zurück Sammlung aller Werte in der Karte.
  

Verwendung der mutableMapOf () Funktion

Das mutableMapOf () function erstellt für uns eine veränderliche Map, sodass wir Elemente in der Map hinzufügen und entfernen können. Dies gibt einen Kotlin zurück MutableMap Oberflächentyp.

val WährungenMutableMap: MutableMap = mutableMapOf ("Naira" bis "Nigeria", "Dollar" bis "USA", "Pfund" bis "UK") println ("Länder sind $ WährungenMutableMap.values") // Länder sind [Nigeria, USA, UK ] println ("Währungen sind $ WährungenMutableMap.keys") // Währungen sind [Naira, Dollar, Pfund] WährungenMutableMap.put ("Cedi", "Ghana") WährungenMutableMap.remove ("Dollar")

Das MutableMap Schnittstelle erweitert das nicht MutableCollection Schnittstelle; Es ist nur der Elternteil Karte Schnittstelle. Es überschreibt die Schlüssel, Einträge und Werte Eigenschaften der übergeordneten Schnittstelle, um sie neu zu definieren. Hier sind einige der zusätzlichen Funktionen, die in verfügbar sind MutableMap Schnittstelle:

• put (Schlüssel: K, Wert: V): fügt das Schlüssel / Wert-Paar in die Karte ein. Dies gibt den vorherigen Wert zurück, der mit dem Schlüssel verknüpft ist, oder null, wenn der Schlüssel zuvor nicht verwendet wurde. 
• entfernen (Schlüssel: K): Entfernt den Schlüssel und den verknüpften Wert aus der Karte. 
• putAll(von: Karte): aktualisiert die Karte mit allen Daten der angegebenen Karte. Neue Schlüssel werden hinzugefügt und vorhandene Schlüssel werden mit neuen Werten aktualisiert. 
• klar(): Entfernt alle Elemente von der Karte. 

Wir können den Wert für einen Schlüssel mit der erhalten() Funktion. Wir können auch die eckige Klammernotation als Abkürzung für verwenden erhalten(). 

print (WährungenMutableMap.get ("Nigeria")) // druckt Naira Druck (WährungenMutableMap ["Nigeria"]) // druckt Naira

Verwendung der hashMapOf () Funktion

Bei Verwendung dieser Funktion wird Java zurückgegeben HashMap Typ, der veränderbar ist. Das HashMap Klasse verwendet eine Hashtabelle, um Java zu implementieren Karte Schnittstelle.  

val personsHashMap: java.util.HashMap = hashMapOf (1 zu "Chike", 2 zu "John", 3 zu "Emeka") PersonsHashMap.put (4, "Chuka") PersonsHashMap.remove (2) print (PersonsHashMap [1]) // wird Chike drucken

Verwendung der linkedHashMap () Funktion

Diese Funktion gibt ein Java zurück LinkedHashMap Typ, der veränderbar ist. Das LinkedHashMap Klasse erweitert Java HashMap und führt eine verknüpfte Liste der Einträge in der Karte in der Reihenfolge, in der sie eingefügt wurden. 

val postalCodesHashMap: java.util.LinkedHashMap = linkedMapOf ("NG" nach "Nigeria", "AU" nach "Australien", "CA" nach "Kanada") postCodesHashMap.put ("NA", "Namibia") postalCodesHashMap.remove ("AU") postalCodesHashMap.get ("CA") // Kanada

Verwendung der sortierteMapOf () Funktion

Diese Funktion gibt ein Java zurück SortedMap Typ, der veränderbar ist. Das Java SortedMap Klasse sieht, dass die Einträge in der Karte in aufsteigender Reihenfolge der Schlüssel verwaltet werden.

val personsSortedMap: java.util.SortedMap = sortiertMapOf (2 zu "Chike", 1 zu "John", 3 zu "Emeka") PersonenSortedMap.put (7, "Adam") PersonenSortedMap.remove (3)

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

Funktionsfunktionen für Sammlungen

Kotlin bietet uns viele nützliche Operatorfunktionen, sogenannte Erweiterungsfunktionen, die in Sammlungen aufgerufen werden können. Werfen wir einen Blick auf einige der nützlichsten.

Das zuletzt() Funktion

Diese Operatorfunktion gibt das letzte Element in einer Auflistung zurück, z. B. eine Liste oder einen Satz. Wir können auch ein Prädikat für die Suche innerhalb einer Teilmenge von Elementen angeben.

val stringList: Liste = listOf ("in", "the", "club") print (stringList.last ()) // druckt "club" // mit einem Prädikat print (stringList.last it.length == 3) / / druckt "the" val intSet: Set = setOf (3, 5, 6, 6, 6, 3) print (intSet.last ()) // druckt 6

Das zuerst() Funktion

Diese Operatorfunktion gibt das erste Element zurück, wenn sie in einer Auflistung wie einer Liste oder einem Satz aufgerufen wird. Wenn ein Prädikat angegeben ist, wird die Operation mit dem Prädikat auf eine Teilmenge von Elementen beschränkt.

print (stringList.first ()) // druckt "in" print (intSet.first ()) // druckt 3

Das max () Funktion

Beim Aufrufen dieser Operatorfunktion für eine Auflistung, z. B. eine Liste oder ein Set, wird das größte Element zurückgegeben, oder null, wenn kein größtes Element gefunden wird.

val intList: Liste = listOf (1, 3, 4) print (intList.max ()) // druckt 4 print (intSet.max ()) // druckt 6 

Das fallen() Funktion

Beim Aufruf dieser Operatorfunktion wird eine neue Liste oder Gruppe zurückgegeben, die alle Elemente außer den ersten n Elementen enthält.

print (stringList.drop (2)) // druckt "club"

Das Plus() Funktion

Diese Operatorfunktion gibt eine Auflistung zurück, die alle Elemente des Originals und dann das angegebene Element enthält, sofern es nicht bereits in der Auflistung enthalten ist. Am Ende wird eine neue Liste erstellt, anstatt die Liste zu ändern.

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

Das Minus() Funktion

Das Gegenteil von dem Plus() Funktion ist die Minus() Funktion. Sie gibt eine Auflistung zurück, die alle Elemente des ursprünglichen Satzes außer dem angegebenen Element enthält. Dadurch wird auch eine neue Liste erstellt, anstatt die Liste zu ändern.

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

Das durchschnittlich() Funktion

Beim Aufruf dieser Operatorfunktion wird eine durchschnittliche Anzahl von Elementen in der Auflistung zurückgegeben.

print (intList.average ()) // druckt 2.6666666666666665

Die meisten dieser Erweiterungsfunktionen sind in der Standardbibliothek der Kotlin-Sammlungen verfügbar. Es wird empfohlen, die Dokumentation durchzulesen, um mehr über die anderen zu erfahren.

Fazit

In diesem Lernprogramm haben Sie die Produktpalette und Sammlungen von API in der Programmiersprache Kotlin kennen gelernt. Im nächsten Tutorial der Kotlin From Scratch-Serie werden Sie mit Funktionen in Kotlin vertraut gemacht. Bis bald!

Um mehr über die Kotlin-Sprache zu lernen, empfehle ich die Kotlin-Dokumentation. Auf Envato Tuts finden Sie auch einige unserer anderen Android-Apps zur Entwicklung von Apps!