Scala List (Liste)
Scala List (Liste)
Scala Liste ist ähnlich wie ein Array, sie die gleiche Art von allen Elementen sind, aber sie sind unterschiedlich: Die Liste ist unveränderlich, kann der Wert nicht geändert werden, sobald sie definiert sind, gefolgt von einer Liste mit rekursiven Struktur (dh, die Struktur der Verknüpfungstabelle) und einem Array Nein. .
Elementtyp T kann als eine Liste der Liste [T] geschrieben werden. Zum Beispiel zeigt die folgende eine Liste der verschiedenen Arten:
// 字符串列表 val site: List[String] = List("w3big", "Google", "Baidu") // 整型列表 val nums: List[Int] = List(1, 2, 3, 4) // 空列表 val empty: List[Nothing] = List() // 二维列表 val dim: List[List[Int]] = List( List(1, 0, 0), List(0, 1, 0), List(0, 0, 1) )
Zwei Grundeinheit Aufbau der Liste istNil und ::
Nil kann auch als eine leere Liste ausgedrückt werden.
Wir können die obigen Beispiele schreiben sind wie folgt:
// 字符串列表 val site = "w3big" :: ("Google" :: ("Baidu" :: Nil)) // 整型列表 val nums = 1 :: (2 :: (3 :: (4 :: Nil))) // 空列表 val empty = Nil // 二维列表 val dim = (1 :: (0 :: (0 :: Nil))) :: (0 :: (1 :: (0 :: Nil))) :: (0 :: (0 :: (1 :: Nil))) :: Nil
Liste der grundlegenden Betriebs
Scala Liste hat drei grundlegende Operationen:
-
head
liefert das erste Element der Liste -
tail
gibt eine Liste, die zusätzlich zu den anderen Elementen des ersten Elements enthält -
isEmpty
liefert true , wenn die Liste leer ist
Für Scala Liste jede Operation kann verwendet werden, um die drei grundlegenden Operationen zum Ausdruck bringen. Beispiele sind wie folgt:
object Test { def main(args: Array[String]) { val site = "w3big" :: ("Google" :: ("Baidu" :: Nil)) val nums = Nil println( "第一网站是 : " + site.head ) println( "最后一个网站是 : " + site.tail ) println( "查看列表 site 是否为空 : " + site.isEmpty ) println( "查看 nums 是否为空 : " + nums.isEmpty ) } }
Die Umsetzung des obigen Codes ist die Ausgabe:
$ vim Test.scala $ scala Test.scala 第一网站是 : w3big 最后一个网站是 : List(Google, Baidu) 查看列表 site 是否为空 : false 查看 nums 是否为空 : true
Verbindungsliste
Sie können die::: Betreiber oder Liste verwenden. :: :()Methode oderList.concat ()-Methode zwei oder Listen mehr zu verbinden. Beispiele sind wie folgt:
object Test { def main(args: Array[String]) { val site1 = "w3big" :: ("Google" :: ("Baidu" :: Nil)) val site2 = "Facebook" :: ("Taobao" :: Nil) // 使用 ::: 运算符 var fruit = site1 ::: site2 println( "site1 ::: site2 : " + fruit ) // 使用 Set.:::() 方法 fruit = site1.:::(site2) println( "site1.:::(site2) : " + fruit ) // 使用 concat 方法 fruit = List.concat(site1, site2) println( "List.concat(site1, site2) : " + fruit ) } }
Die Umsetzung des obigen Codes ist die Ausgabe:
$ vim Test.scala $ scala Test.scala site1 ::: site2 : List(w3big, Google, Baidu, Facebook, Taobao) site1.:::(site2) : List(Facebook, Taobao, w3big, Google, Baidu) List.concat(site1, site2) : List(w3big, Google, Baidu, Facebook, Taobao)
List.fill ()
Wir verwenden List.fill () Methode, um eine bestimmte Anzahl von Wiederholungen einer Liste von Elementen zu erzeugen:
object Test { def main(args: Array[String]) { val site = List.fill(3)("w3big") // 重复 w3big 3次 println( "site : " + site ) val num = List.fill(10)(2) // 重复元素 2, 10 次 println( "num : " + num ) } }
Die Umsetzung des obigen Codes ist die Ausgabe:
$ vim Test.scala $ scala Test.scala site : List(w3big, w3big, w3big) num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)
List.tabulate ()
List.tabulate () -Methode verwendet, um die Liste durch die gegebene Funktion zu erstellen.
Das erste Argument die Anzahl der Elemente ist, die zweidimensional sein kann, der zweite Parameter für die Funktion angegeben, berechnen wir die Ergebnisse durch die Funktion angibt und gibt den Wert in die Liste eingefügt, der Startwert 0, die Beispiele sind wie folgt:object Test { def main(args: Array[String]) { // 通过给定的函数创建 5 个元素 val squares = List.tabulate(6)(n => n * n) println( "一维 : " + squares ) // 创建二维列表 val mul = List.tabulate( 4,5 )( _ * _ ) println( "多维 : " + mul ) } }
Die Umsetzung des obigen Codes ist die Ausgabe:
$ vim Test.scala $ scala Test.scala 一维 : List(0, 1, 4, 9, 16, 25) 多维 : List(List(0, 0, 0, 0, 0), List(0, 1, 2, 3, 4), List(0, 2, 4, 6, 8), List(0, 3, 6, 9, 12))
List.reverse
List.reverse Sequenz für invertierte Liste Beispiele sind wie folgt:
object Test { def main(args: Array[String]) { val site = "w3big" :: ("Google" :: ("Baidu" :: Nil)) println( "site 反转前 : " + site ) println( "site 反转前 : " + site.reverse ) } }
Die Umsetzung des obigen Codes ist die Ausgabe:
$ vim Test.scala $ scala Test.scala site 反转前 : List(w3big, Google, Baidu) site 反转前 : List(Baidu, Google, w3big)
Scala Liste gemeinsame Methoden
In der folgenden Tabelle sind die Scala Liste gängige Methoden:
Nein. | Verfahren und Beschreibung |
---|---|
1 | def + :( Elem: A): Liste [A] In der Liste der Pre-Elemente scala> val x = List(1) x: List[Int] = List(1) scala> val y = 2 +: x y: List[Int] = List(2, 1) scala> println(x) List(1) |
2 | def: :( x: A): Liste [A] Am Anfang der Liste Elemente hinzufügen |
3 | def :: :( Präfix: Liste [A ]): Liste [A] Am Anfang der Liste der angegebenen Listenelement hinzufügen |
4 | def: + (Elem: A) : Liste [A] Nachdem Sie die Liste kopieren Elemente hinzuzufügen. scala> val a = List(1) a: List[Int] = List(1) scala> val b = a :+ 2 b: List[Int] = List(1, 2) scala> println(a) List(1) |
5 | def addString (b: String): String Fügen Sie alle Elemente der Liste zu String |
6 | def addString (b: Stringbuilder, sep : String): String Fügen Sie alle Elemente der Liste zu Stringbuilder, und geben Sie den Begrenzer |
7 | def gelten (n: int): A Hier finden Sie eine Liste der Elemente von Index |
8 | def enthält (Elem: Any): Boolean Erkennen, ob die Liste das angegebene Element enthält |
9 | def copyToArray (xs: Array [A ], Beginn: Int, len: Int): Einheit Kopiert die Elemente der Liste in einem Array. |
10 | def verschieden: Liste [A] Entfernen Sie doppelte Elemente der Liste und gibt eine neue Liste |
11 | def Drop (n: int): Liste [A] Entsorgen Sie die ersten n Elemente und gibt eine neue Liste |
12 | def dropRight (n: int): Liste [A] Entsorgen Sie die letzten n Elemente und gibt eine neue Liste |
13 | def dropWhile (p: (A) => Boolean): Liste [A] Verwerfen Element links nach rechts, bis die Bedingung nicht erfüllt p |
14 | def endsWith [B] (das: Seq [B]): Boolean Nachweis, ob die Liste am Ende der angegebenen Reihenfolge |
15 | def entspricht (also: Any): Boolean Bestimmen Sie, ob die gleiche |
16 | def existiert (p: (A) => Boolean): Boolean Die Analyse der in der Liste der Elemente angegebenen Bedingungen vorliegt. L bestimmen, ob es ein Element: scala> l.exists(s => s == "Hah") res7: Boolean = true |
17 | Filter def (p: (A) => Boolean): Liste [A] Alle Elemente der Ausgabesymbole angegebenen Bedingung. Die Länge des Filterelementes 3: scala> l.filter(s => s.length == 3) res8: List[String] = List(Hah, WOW) |
18 | def forall (p: (A) => Boolean): Boolean Nachweis aller Elemente. Zum Beispiel: um zu bestimmen, ob alle Elemente der "H" am Anfang: scala> l.forall (s => s.startsWith ( "H")) res10: Boolean = false |
19 | def foreach (f: (A) => Unit): Einheit Alle Elemente der Funktion zu der Liste |
20 | def Kopf: A Holen Sie sich das erste Element der Liste |
21 | def indexOf (Elem: A, aus : int): int Finden Sie den Ort des ersten Auftretens des Elements an der angegebenen Position aus |
22 | def init: Liste [A] Gibt alle Elemente, mit Ausnahme des letzten |
23 | schneiden def (das: Seq [A ]): Liste [A] Berechnen einer Mehrzahl von der Kreuzung von Sätzen |
24 | def isEmpty: Boolean Erkennen, ob die Liste leer ist |
25 | def Iterator: Iterator [A] Erstellen Sie einen neuen Iterator um die Elemente zu iterieren |
26 | def letzte: A Gibt das letzte Element |
27 | def lastIndexOf (Elem: A, Ende : Int): Int An der Stelle angegebenen Endposition beginnen nach dem letzten Vorkommen des Elements suchen |
28 | def Länge: Int Zurück zur Liste Länge |
29 | map def [B] (f: (A) => B): Liste [B] Durch eine bestimmte Methode wird neu berechnet werden alle Elemente |
30 | def max: A Finden Sie die maximale Element |
31 | def min: A Finden Sie das kleinste Element |
32 | def mkString: String Eine Liste aller Elemente als String |
33 | def mkString (September: String): String Abscheider wird eine Liste aller Elemente als String angezeigt werden |
34 | def umkehren: Liste [A] Reverse-Liste |
35 | def sortierten [B>: A] : Liste [A] Liste Sortierung |
36 | def starts [B] (das: Seq [B], Offset: Int): Boolean Erkennen, ob die Liste der angegebenen Reihenfolge an der angegebenen Position enthält |
37 | def Summe: A Berechnung und Sammlung von Elementen |
38 | def Schwanz: Liste [A] Gibt alle Elemente zurück, mit Ausnahme der ersten |
39 | nehmen def (n: int): Liste [A] Extrahieren der ersten n Elemente der Liste |
40 | def takeRight (n: int): Liste [A] n Elemente extrahiert Liste |
41 | def toArray: Array [A] Liste in ein Array |
42 | def toBuffer [B>: A] : Puffer [B] Zurück Puffer enthält eine Liste aller Elemente |
43 | def toMap [T, U]: Map [T, U] Liste umgewandelt Karte |
44 | def toSeq: Seq [A] Liste konvertieren Seq |
45 | Toset def [B>: A] : Stellen Sie [B] Liste konvertieren Set |
46 | def toString (): String Umgerechnet auf eine String-Liste |
Weitere Möglichkeiten , um zu verweisen der API - Dokumentation