English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Scala教程

Scala List (Liste)

ScalaZusammenstellung

Scala-Listen ähneln Arrays, sie haben alle Elemente desselben Typs, aber sie unterscheiden sich auch: Listen sind nicht veränderlich, Werte können einmal definiert worden nicht geändert werden, und sie haben eine rekursive Struktur (also Linkliste), während Arrays dies nicht tun..

Listelementen können als List[T] angegeben werden. Zum Beispiel sind in der folgenden Liste verschiedene Typen von Listen aufgeführt:

//　字符串列表
val site: List[String] = List("w3codebox", "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)
　　　)

构造列表的两个基本单位是 Nil 和 ::

Nil 也可以表示为一个空列表。

以上示例我们可以写成如下所示：

//　字符串列表
val site = "w3codebox" :: ("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

列表基本操作

Scala列表有三个基本操作：

  • head 返回列表第一个元素

  • tail 返回一个列表，包含除了第一元素之外的其他元素

  • isEmpty 在列表为空时返回true

对于Scala列表的任何操作都可以使用这三个基本操作来表达。示例如下:

//　字符串列表
object Test {
　　　def main(args: Array[String]) {
　　　　　　val site = "w3codebox" :: ("Google" :: ("Baidu" :: Nil))
　　　　　　val nums = Nil
　　　　　　println("第一网站是 : "　+　site.head )
　　　　　　println("最后一个网站是 : "　+　site.tail )
　　　　　　println("查看列表 site 是否为空 : "　+　site.isEmpty )
　　　　　　println("查看 nums 是否为空 : "　+　nums.isEmpty )
　　　}
}

执行以上代码，输出结果为：

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

连接列表

你可以使用 ::: 运算符或 List.:::() 方法或 List.concat() 方法来连接两个或多个列表。示例如下:

object Test {
　　　def main(args: Array[String]) {
　　　　　　val site1　= "w3codebox" :: ("Google" :: ("Baidu" :: Nil))
　　　　　　val site2　= "Facebook" :: ("Taobao" :: Nil)
　　　　　　//　使用 ::: 运算符
　　　　　　var fruit = site1　::: site2
　　　　　　println("site1　::: site2　: "　+　fruit )
　　　　　　
　　　　　　//　使用 List.:::() 方法
　　　　　　fruit = site1.:::(site2)
　　　　　　println("site1.:::(site2) : "　+　fruit )
　　　　　　//　使用 concat 方法
　　　　　　fruit = List.concat(site1, site2)
　　　　　　println("List.concat(site1, site2) : "　+　fruit　　)
　　　　　　
　　　}
}

执行以上代码，输出结果为：

$ vim Test.scala　
$ scala Test.scala　
site1　::: site2　: List(w3codebox, Google, Baidu, Facebook, Taobao)
site1.:::(site2List(Facebook, Taobao, w3codebox, Google, Baidu)
List.concat(site)1, site2) : List(w3codebox, Google, Baidu, Facebook, Taobao)

List.fill()

我们可以使用 List.fill() 方法来创建一个指定重复数量的元素列表：

object Test {
　　　def main(args: Array[String]) {
　　　　　　val site = List.fill(3)("w3codebox)　//　重复 w3codebox　3次
　　　　　　println( "site : "　+　site )
　　　　　　val num = List.fill(10)(2)　　　　　　　　　//　重复元素　2,　10　次
　　　　　　println( "num : "　+　num )
　　　}
}

执行以上代码，输出结果为：

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

List.tabulate()

List.tabulate() 方法是通过给定的函数来创建列表。

方法的第一个参数为元素的数量，可以是二维的，第二个参数为指定的函数，我们通过指定的函数计算结果并返回值插入到列表中，起始值为 0，示例如下：

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 )
　　　}
}

执行以上代码，输出结果为：

$ 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 用于将列表的顺序反转，示例如下：

object Test {
　　　def main(args: Array[String]) {
　　　　　　val site = "w3codebox" :: ("Google" :: ("Baidu" :: Nil))
　　　　　　println( "site 反转前 : "　+　site )
　　　　　　println( "site 反转后 : "　+　site.reverse )
　　　}
}

执行以上代码，输出结果为：

$ vim Test.scala　
$ scala Test.scala　
site 反转前 : List(w3codebox, Google, Baidu)
site reversed : List(Baidu, Google, w)3codebox)

Häufig verwendete Methoden von Scala List

Die folgende Tabelle zeigt die häufig verwendeten Methoden von Scala List:

NummerMethoden und Beschreibungen
1

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

Fügt Elemente vor 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 an den Anfang der Liste hinzu

3

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

Fügt die Elemente der angegebenen Liste an den 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 zu einem StringBuilder hinzu

6

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

Fügt alle Elemente der Liste zu einem StringBuilder hinzu und gibt den Trennzeichen an

7

def apply(n: Int): A

Beschafft das Element anhand der Listeindezes

8

def contains(elem: Any): Boolean

Überprü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 wiederholte Elemente aus der Liste und gibt die neue Liste zurück

11

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

Entfernt die ersten n Elemente und gibt die neue Liste zurück

12

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

Entfernt die letzten n Elemente und gibt die neue Liste zurück

13

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

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

14

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

Überprüfen Sie, ob die Liste mit einer bestimmten Sequenz endet

15

def equals(that: Any): Boolean

Überprüfen Sie die Gleichheit

16

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

Überprüfen Sie, ob ein bestimmtes Element in der Liste unter bestimmten Bedingungen existiert.

Überprüfen Sie, ob l ein bestimmtes Element enthält:

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

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

Geben Sie alle Elemente aus, die die angegebene Bedingung erfüllen.

Filtern Sie Elemente mit der Länge3der Elemente:

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

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

Überprüfen Sie alle Elemente.

Zum Beispiel: Überprüfen Sie, ob alle Elemente mit "H" beginnen:

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

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

Wenden Sie die Funktion auf alle Elemente der Liste an

20

def head: A

Geben Sie das erste Element der Liste zurück

21

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

Von der angegebenen Position from Beginnen Sie mit der Suche nach der ersten Position des Elements

22

def init: List[A]

Geben Sie alle Elemente zurück, außer dem letzten

23

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

Berechnen Sie den Schnitt mehrerer Mengen

24

def isEmpty: Boolean

Überprüfen Sie, ob die Liste leer ist

25

def iterator: Iterator[A]

Erstellen Sie einen neuen Iterator, um die Elemente zu iterieren

26

def last: A

Geben Sie das letzte Element zurück

27

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

Suchen Sie den letzten Vorkommen des Elements an der angegebenen Position end

28

def length: Int

Geben Sie die Länge der Liste zurück

29

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

Berechnen Sie alle Elemente neu durch die angegebene Methode

30

def max: A

Suchen Sie das größte Element

31

defmin: A

FindetdenkleinstenElement

32

defmkString: String

ZeigtalleElemente derListealsZeichenkettean

33

defmkString(sep: String): String

ZeigtalleElemente derListealsZeichenkettemitdemTrennzeichenan

34

defreverse:List[A]

ListeUmkehren

35

defsorted[B >: A]:List[A]

ListeSortieren

36

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

ÜberprüftobdieListe andergegebenenPositiondieangegebeneSequenzenthält

37

defsum: A

Berechnet dieSumme derElemente derZusammenstellung

38

deftail:List[A]

GibtalleElementezurück，außerdemersten

39

deftake(n: Int):List[A]

ExtrahiertdievorderennElemente derListe

40

deftakeRight(n: Int):List[A]

ExtrahiertdieletznElemente derListe

41

deftoArray:Array[A]

ListenumArrayumwandeln

42

deftoBuffer[B >: A]:Buffer[B]

GibtdenPufferzurück，deralleElemente derListeenthält

43

deftoMap[T, U]:Map[T, U]

ListenumMapumwandeln

44

deftoSeq:Seq[A]

ListenumSequmwandeln

45

deftoSet[B >: A]:Set[B]

ListenumSetumwandeln

46

deftoString():String

ListenumZeichenketteumwandeln

MehrMethodenkönnendieserDokumentationentnommenwerden APIDokumentation

ScalaZusammenstellung

ScalaIterator(Iterator)ScalaCollection(Zusammenstellung)