Scala List

Scala 集合Scala Collections

Scala-Listen ähneln Arrays darin, dass alle Elemente denselben Typ haben, unterscheiden sich aber auch: Listen sind unveränderlich, was bedeutet, dass ein einmal definierter Wert nicht geändert werden kann, und Listen haben eine rekursive Struktur (d. h. eine verkettete Listenstruktur), während Arrays dies nicht haben.

Der Elementtyp T einer Liste kann als List[T] geschrieben werden. Zum Beispiel listet das Folgende verschiedene Arten von Listen auf:

Beispiel

// String-Liste
val site: List[String] = List("Example", "Google", "Baidu")

// Ganzzahlenliste
val nums: List[Int] = List(1, 2, 3, 4)

// Leere Liste
val empty: List[Nothing] = List()

// Zweidimensionale Liste
val dim: List[List[Int]] =
   Liste(
      Liste(1, 0, 0),
      Liste(0, 1, 0),
      Liste(0, 0, 1)
   )

Die beiden Grundeinheiten zum Aufbau einer Liste sind Nil und ::Nilund::

NilEs kann auch als leere Liste dargestellt werden.

Das obige Beispiel kann wie folgt geschrieben werden:

Beispiel

// String-Liste
val site = "Example" :: ("Google" :: ("Baidu" :: Nil))

// Ganzzahlenliste
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))

// Leere Liste
val empty = Nil

// Zweidimensionale Liste
val dim = (1 :: (0 :: (0 :: Nil))) ::
          (0 :: (1 :: (0 :: Nil))) ::
          (0 :: (0 :: (1 :: Nil))) :: Nil

Grundlegende Listenoperationen

Scala-Listen haben drei grundlegende Operationen:

  • headGibt das erste Element der Liste zurück
  • tailGibt eine Liste zurück, die alle Elemente außer dem ersten enthält
  • isEmptyGibt true zurück, wenn die Liste leer ist

Jede Operation auf Scala-Listen kann mit diesen drei grundlegenden Operationen ausgedrückt werden. Beispiele sind wie folgt:

Beispiel

// String-Liste
object Test {
   def main(args: Array[String]) {
      val site = "Example" :: ("Google" :: ("Baidu" :: Nil))
      val nums = Nil

      println( "Die erste Website ist: " + site.head )
      println( "Die letzte Website ist: " + site.tail )
      println( "Prüfen, ob die Liste site leer ist: " + site.isEmpty )
      println( "Prüfen, ob nums leer ist: " + nums.isEmpty )
   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

$ vim Test.scala 
$ scala Test.scala 
第一网站是 : Example
最后一个网站是 : List(Google, Baidu)
查看列表 site 是否为空 : false
查看 nums 是否为空 : true

Verkettung von Listen

Sie können den:::::: Operator oder dieList.:::()List.:::() Methode oder dieList.concat()concat-Methode verwenden, um zwei oder mehr Listen zu verketten. Beispiele sind wie folgt:

Beispiel

object Test {
   def main(args: Array[String]) {
      val site1 = "Example" :: ("Google" :: ("Baidu" :: Nil))
      val site2 = "Facebook" :: ("Taobao" :: Nil)

      // Verwendung des :::-Operators
      var fruit = site1 ::: site2
      println( "site1 ::: site2 : " + fruit )
     
      // Verwendung der List.:::()-Methode
      fruit = site1.:::(site2)
      println( "site1.:::(site2) : " + fruit )

      // Verwendung der concat-Methode
      fruit = List.concat(site1, site2)
      println( "List.concat(site1, site2) : " + fruit  )
     

   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

$ vim Test.scala 
$ scala Test.scala 
site1 ::: site2 : List(Example, Google, Baidu, Facebook, Taobao)
site1.:::(site2) : List(Facebook, Taobao, Example, Google, Baidu)
List.concat(site1, site2) : List(Example, Google, Baidu, Facebook, Taobao)

List.fill()

Wir können die List.fill()-Methode verwenden, um eine Liste mit einer bestimmten Anzahl wiederholter Elemente zu erstellen:

Beispiel

object Test {
   def main(args: Array[String]) {
      val site = List.fill(3)("Beispiel") // Beispiel 3-mal wiederholen
      println( "site : " + site  )

      val num = List.fill(10)(2)         // Element 2 10-mal wiederholen
      println( "num : " + num  )
   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

$ vim Test.scala 
$ scala Test.scala 
site : List(Example, Example, Example)
num : List(2, 2, 2, 2, 2, 2, 2, 2, 2, 2)

List.tabulate()

Die Methode List.tabulate() erstellt eine Liste mithilfe einer gegebenen Funktion.

Der erste Parameter der Methode ist die Anzahl der Elemente, die zweidimensional sein kann; der zweite Parameter ist die angegebene Funktion. Wir berechnen das Ergebnis mithilfe der angegebenen Funktion und fügen den zurückgegebenen Wert in die Liste ein, beginnend bei 0. Beispiele sind wie folgt:

Beispiel

object Test {
   def main(args: Array[String]) {
      // 5 Elemente mit der angegebenen Funktion erstellen
      val squares = List.tabulate(6)(n => n * n)
      println( "Eindimensional: " + squares  )

      // Eine zweidimensionale Liste erstellen
      val mul = List.tabulate( 4,5 )( _ * _ )      
      println( "Mehrdimensional: " + mul  )
   }
}

Das Ausführen des obigen Codes erzeugt die folgende 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 wird verwendet, um die Reihenfolge einer Liste umzukehren. Beispiele sind wie folgt:

Beispiel

object Test {
   def main(args: Array[String]) {
      val site = "Example" :: ("Google" :: ("Baidu" :: Nil))
      println( "Vor der Umkehrung von site: " + site )

      println( "Nach der Umkehrung von site: " + site.reverse )
   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

$ vim Test.scala 
$ scala Test.scala 
site 反转前 : List(Example, Google, Baidu)
site 反转后 : List(Baidu, Google, Example)

Häufige Methoden für Scala List

Die folgende Tabelle listet häufige Methoden für Scala List auf:

Nein. Methode und Beschreibung
1

def +:(elem: A): List[A]

Fügt ein Element am Anfang der Liste hinzu

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): List[A]

Fügt ein Element am Anfang der Liste hinzu
3

def :::(prefix: List[A]): List[A]

Fügt Elemente der angegebenen Liste am Anfang der Liste hinzu
4

def :+(elem: A): List[A]

Kopiert die Liste nach dem Hinzufügen von Elementen

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: StringBuilder): StringBuilder

Fügt alle Elemente der Liste einem StringBuilder hinzu
6

def addString(b: StringBuilder, sep: String): StringBuilder

Fügt alle Elemente der Liste einem StringBuilder mit einem angegebenen Trennzeichen hinzu
7

def apply(n: Int): A

Ruft ein Element anhand des Listenindex ab
8

def contains(elem: Any): Boolean

Prüft, ob die Liste das angegebene Element enthält
9

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

Kopiert die Elemente der Liste in ein Array
10

def distinct: List[A]

Entfernt doppelte Elemente aus der Liste und gibt eine neue Liste zurück
11

def drop(n: Int): List[A]

Verwirft die ersten n Elemente und gibt eine neue Liste zurück
12

def dropRight(n: Int): List[A]

Verwirft die letzten n Elemente und gibt eine neue Liste zurück
13

def dropWhile(p: (A) => Boolean): List[A]

Verwirft Elemente von links nach rechts, bis die Bedingung p nicht mehr erfüllt ist
14

def endsWith[B](that: Seq[B]): Boolean

Prüft, ob die Liste mit der angegebenen Sequenz endet
15

def equals(that: Any): Boolean

Bestimmt, ob sie gleich sind
16

def exists(p: (A) => Boolean): Boolean

Prüft, ob ein Element, das die angegebene Bedingung erfüllt, in der Liste existiert

Prüft, ob die Liste l ein bestimmtes Element enthält

scala> l.exists(s => s == "Hah")
res7: Boolean = true
17

def filter(p: (A) => Boolean): List[A]

Gibt alle Elemente aus, die die angegebene Bedingung erfüllen

Filtert Elemente mit Länge 3 heraus

scala> l.filter(s => s.length == 3)
res8: List[String] = List(Hah, WOW)
18

def forall(p: (A) => Boolean): Boolean

Überprüft alle Elemente

Zum Beispiel: überprüft, ob alle Elemente mit "H" beginnen

scala> l.forall(s => s.startsWith("H")) res10: Boolean = false
19

def foreach(f: (A) => Unit): Unit

Wendet eine Funktion auf alle Elemente der Liste an
20

def head: A

Ruft das erste Element der Liste ab
21

def indexOf(elem: A, from: Int): Int

Findet die Position des ersten Vorkommens eines Elements ab der angegebenen Position 'from'
22

def init: List[A]

Gibt alle Elemente außer dem letzten zurück
23

def intersect(that: Seq[A]): List[A]

Berechnet die Schnittmenge mehrerer Sammlungen
24

def isEmpty: Boolean

Prüft, ob die Liste leer ist
25

def iterator: Iterator[A]

Erstellt einen neuen Iterator, um über die Elemente zu iterieren
26

def last: A

Gibt das letzte Element zurück
27

def lastIndexOf(elem: A, end: Int): Int

Findet die Position des letzten Vorkommens eines Elements beginnend bei der angegebenen Position 'end'
28

def length: Int

Gibt die Länge der Liste zurück
29

def map[B](f: (A) => B): List[B]

Berechnet alle Elemente mit der angegebenen Methode neu
30

def max: A

Findet das größte Element
31

def min: A

Findet das kleinste Element
32

def mkString: String

Gibt alle Elemente der Liste als Zeichenkette aus
33

def mkString(sep: String): String

Gibt alle Elemente der Liste unter Verwendung eines Trennzeichens als Zeichenkette aus
34

def reverse: List[A]

Kehrt die Liste um
35

def sorted[B >: A]: List[A]

Sortiert die Liste
36

def startsWith[B](that: Seq[B], offset: Int): Boolean

Prüft, ob die Liste die angegebene Sequenz an der angegebenen Position enthält
37

def sum: A

Berechnet die Summe der Elemente der Sammlung
38

def tail: List[A]

Gibt alle Elemente außer dem ersten zurück
39

def take(n: Int): List[A]

Extrahiert die ersten n Elemente der Liste
40

def takeRight(n: Int): List[A]

Extrahiert die letzten n Elemente der Liste
41

def toArray: Array[A]

Konvertiert die Liste in ein Array
42

def toBuffer[B >: A]: Buffer[B]

Gibt einen Puffer zurück, der alle Elemente der Liste enthält
43

def toMap[T, U]: Map[T, U]

Konvertiert List in Map
44

def toSeq: Seq[A]

Konvertiert List in Seq
45

def toSet[B >: A]: Set[B]

Konvertiert List in Set
46

def toString(): String

Konvertiert die Liste in einen String

Weitere Methoden finden Sie in derAPI-Dokumentation

Scala 集合Scala Collections

Andere Erweiterungen