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

Tutoriel Scala

Scala List (liste)

Collections Scala

Les listes Scala sont similaires aux tableaux, toutes leurs éléments ont le même type, mais elles ont aussi des différences : les listes sont immuables, une fois définies, elles ne peuvent pas être modifiées, et elles ont également une structure récursive (c'est-à-dire une structure de liste chaînée) tandis que les tableaux ne le sont pas..

Les éléments d'une liste peuvent être de type T, par exemple, voici une liste de différents types de listes :

//　字符串列表
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 )
　　　}
}

Exécuter le code suivant, le résultat est :

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

Exécuter le code suivant, le résultat est :

$ 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()

Nous pouvons utiliser la méthode List.fill() pour créer une liste d'éléments répétés d'un nombre spécifié :

object Test {
　　　def main(args: Array[String]) {
　　　　　　val site = List.fill(3)("w3codebox)　//　Répéter w3codebox　3fois
　　　　　　println( "site : "　+　site )
　　　　　　val num = List.fill(10)(2)　　　　　　　　　//　Éléments répétés　2,　10　fois
　　　　　　println( "num : "　+　num )
　　　}
}

Exécuter le code suivant, le résultat est :

$ 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()

La méthode List.tabulate() crée une liste en utilisant une fonction donnée.

Le premier paramètre de la méthode est le nombre d'éléments, il peut être bidimensionnel, le second paramètre est la fonction spécifiée, nous calculons le résultat à l'aide de la fonction spécifiée et insérons la valeur dans la liste, la valeur de départ est 0, voici un exemple :

object Test {
　　　def main(args: Array[String]) {
　　　　　　//　Créer une liste en utilisant une fonction donnée　5　éléments
　　　　　　val carrés = List.tabulate(6)(n => n　*　n)
　　　　　　println( "Unidimensionnel : "　+　carrés )
　　　　　　//　Créer une liste bidimensionnelle
　　　　　　val mul = List.tabulate(　4,5　)( _,　*　_　　　　　　
　　　　　　println( "Multidimensionnel : "　+　mul )
　　　}
}

Exécuter le code suivant, le résultat est :

$ vim Test.scala　
$ scala Test.scala　
Unidimensionnel : List(0,　1,　4,　9,　16,　25)
Multidimensionnel : 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 est utilisé pour inverser l'ordre de la liste, voici un exemple :

object Test {
　　　def main(args: Array[String]) {
　　　　　　val site = "w3codebox" :: ("Google" :: ("Baidu" :: Nil))
　　　　　　println( "site réversé avant : "　+　site )
　　　　　　println( "site réversé après : "　+　site.reverse )
　　　}
}

Exécuter le code suivant, le résultat est :

$ vim Test.scala　
$ scala Test.scala　
site réversée avant : List(w3codebox, Google, Baidu)
site　inversé　:　List(Baidu,　Google,　w3codebox)

Méthodes couramment utilisées de Scala List

Le tableau suivant liste les méthodes couramment utilisées de Scala List :

NuméroMéthodes et descriptions
1

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

Ajoute des éléments à la liste avant la pré-allocation

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]

Ajoute l'élément au début de la liste

3

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

Ajoute les éléments de la liste spécifiée au début de la liste

4

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

Copie la liste après l'ajout des éléments.

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

Ajoute tous les éléments de la liste à StringBuilder

6

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

Ajoute tous les éléments de la liste à StringBuilder, en spécifiant le séparateur

7

def apply(n: Int): A

Obtient l'élément à l'indice de la liste

8

def contains(elem: Any): Boolean

Vérifie si la liste contient l'élément spécifié

9

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

Copie les éléments de la liste dans un tableau.

10

def distinct: List[A]

Supprime les éléments répétés de la liste et retourne une nouvelle liste

11

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

Supprime les premiers n éléments et retourne une nouvelle liste

12

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

Supprime les derniers n éléments et retourne une nouvelle liste

13

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

Délaisser les éléments de gauche à droite jusqu'à ce que la condition p ne soit plus valable

14

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

Vérifier si la liste se termine par une séquence spécifiée

15

def equals(that: Any): Boolean

Vérifier si elles sont égales

16

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

Vérifier si l'élément spécifié dans la liste répond à la condition.

Vérifier si l'existe un élément dans l:

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

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

Sortir tous les éléments qui répondent à la condition spécifiée.

Filtrer les éléments de longueur3Des éléments :

scala> l.filter(s => s.length ==　3)
res8: Liste des chaînes de caractères = List(Hah, WOW)
18

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

Vérifier tous les éléments.

Par exemple : vérifier si tous les éléments commencent par "H" :

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

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

Appliquer la fonction à tous les éléments de la liste

20

def head: A

Obtenir l'élément premier de la liste

21

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

À partir de la position spécifiée from Commencer à rechercher la position de la première apparition de l'élément

22

def init: List[A]

Retourner tous les éléments, sauf le dernier

23

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

Calculer l'intersection de plusieurs ensembles

24

def isEmpty: Boolean

Vérifier si la liste est vide

25

def iterator: Iterator[A]

Créer un nouveau itérateur pour itérer sur les éléments

26

def last: A

Retourner l'élément dernier

27

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

Recherche de la dernière position d'apparition de l'élément à partir de la position spécifiée end

28

def length: Int

Retourner la longueur de la liste

29

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

Recalculer tous les éléments par la méthode donnée

30

def max: A

Recherche de l'élément maximal

31

def min: A

Recherche de l'élément le plus petit

32

def mkString: String

Affichage de tous les éléments de la liste sous forme de chaîne

33

def mkString(sep: String): String

Affichage de tous les éléments de la liste sous forme de chaîne avec un séparateur

34

def reverse: List[A]

Inversion de la liste

35

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

Tri de la liste

36

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

Vérifie si la liste contient une séquence spécifiée à une position spécifiée

37

def sum: A

Calcul de la somme des éléments de la collection

38

def tail: List[A]

Retourne tous les éléments, sauf le premier

39

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

Extraction des n premiers éléments de la liste

40

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

Extraction des n derniers éléments de la liste

41

def toArray: Array[A]

Conversion de liste en tableau

42

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

Retourne un tampon contenant tous les éléments de la liste

43

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

Conversion de liste en Map

44

def toSeq: Seq[A]

Conversion de liste en Seq

45

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

Conversion de liste en ensemble

46

def toString(): String

Conversion de liste en chaîne

Plus de méthodes peuvent être consultées Documentation de l'API

Collections Scala

Iterateur Scala (Iterator)Collection Scala (collections)