Liste Scala (liste)
Liste Scala (liste)
Liste Scala est similaire à un tableau, ils sont le même type de tous les éléments, mais ils sont différents: La liste est immuable, la valeur ne peut pas être changé une fois qu'ils sont définis, suivi d'une liste avec une structure récursive (qui est, la structure de la table de liaison) et un tableau Non. .
Type d'élément T peut être écrite comme une liste de la liste [T]. Par exemple, ce qui suit montre une liste des différents types:
// 字符串列表 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) )
Deux structure de l' unité de base de la liste estNil et ::
Nil peut également être exprimé sous la forme d' une liste vide.
Nous pouvons écrire les exemples ci-dessus sont les suivantes:
// 字符串列表 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 des d'exploitation de base
Liste Scala dispose de trois opérations de base:
-
head
renvoie le premier élément de la liste - la
tail
retourne une liste qui contient , en plus des autres éléments du premier élément -
isEmpty
retourne true si la liste est vide
Pour la liste Scala toute opération peut être utilisée pour exprimer les trois opérations de base. Des exemples sont les suivants:
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 ) } }
Mise en œuvre du code ci-dessus, la sortie est:
$ vim Test.scala $ scala Test.scala 第一网站是 : w3big 最后一个网站是 : List(Google, Baidu) 查看列表 site 是否为空 : false 查看 nums 是否为空 : true
Liste des connexions
Vous pouvez utiliser le::: opérateur ou Liste. :: :()Méthode ou méthodeList.concat ()pour connecter deux ou plusieurs listes. Des exemples sont les suivants:
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 ) } }
Mise en œuvre du code ci-dessus, la sortie est:
$ 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 ()
Nous pouvons utiliser List.fill () pour créer un certain nombre de répétitions d'une liste d'éléments:
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 ) } }
Mise en œuvre du code ci-dessus, la sortie est:
$ 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 ()
méthode List.tabulate () est utilisée pour créer la liste par la fonction donnée.
Le premier argument est le nombre d'éléments, qui peuvent être à deux dimensions, le second paramètre pour la fonction spécifiée, on calcule les résultats en spécifiant la fonction et renvoie la valeur insérée dans la liste, la valeur de départ est 0, les exemples sont les suivants: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 ) } }
Mise en œuvre du code ci-dessus, la sortie est:
$ 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
séquence List.reverse liste inversée, les exemples sont les suivants:
object Test { def main(args: Array[String]) { val site = "w3big" :: ("Google" :: ("Baidu" :: Nil)) println( "site 反转前 : " + site ) println( "site 反转前 : " + site.reverse ) } }
Mise en œuvre du code ci-dessus, la sortie est:
$ vim Test.scala $ scala Test.scala site 反转前 : List(w3big, Google, Baidu) site 反转前 : List(Baidu, Google, w3big)
méthodes communes Liste Scala
Le tableau suivant présente les méthodes communes Liste Scala:
Non. | Méthode et description |
---|---|
1 | def + :( elem: A): Liste [A] Ajouter à la liste des pré-éléments 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] Au début de la liste pour ajouter des éléments |
3 | def :: :( préfixe: Liste [A ]): Liste [A] Au début de la liste pour ajouter l'élément de liste spécifiée |
4 | def: + (elem: A) : Liste [A] Après avoir copié la liste pour ajouter 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 Ajouter tous les éléments de la liste pour StringBuilder |
6 | def addString (b: StringBuilder, septembre : String): StringBuilder Ajouter tous les éléments de la liste pour StringBuilder et spécifier le délimiteur |
7 | appliquer def (n: Int): A Obtenir une liste d'éléments par index |
8 | def contient (elem: Any): Boolean Détecter si la liste contient l'élément spécifié |
9 | def copyToArray (xs: Array [A ], lancez: Int, len: Int): Unité Copie les éléments de la liste dans un tableau. |
10 | def distincte: Liste [A] Supprimer les doublons de la liste, et retourne une nouvelle liste |
11 | def drop (n: Int): Liste [A] Jeter les n premiers éléments, et retourne une nouvelle liste |
12 | def dropRight (n: Int): Liste [A] Jeter les n derniers éléments, et retourne une nouvelle liste |
13 | def dropWhile (p: (A) => Boolean): Liste [A] élément Jeter gauche à droite, jusqu'à ce que la condition ne p satisfait |
14 | def endsWith [B] (que: Seq [B]): Boolean Détecter si la liste à la fin de la séquence spécifiée |
15 | def est égal à (que: Tout):Boolean Déterminer si la même |
16 | existe def (p: (A) => Boolean): Boolean Analyser les conditions spécifiées dans la liste des éléments existent. L déterminer s'il y a un élément: scala> l.exists(s => s == "Hah") res7: Boolean = true |
17 | def filtre (p: (A) => Boolean): Liste [A] Tous les éléments de symboles de sortie spécifiés état. La longueur de l'élément filtrant 3: scala> l.filter(s => s.length == 3) res8: List[String] = List(Hah, WOW) |
18 | def forall (p: (A) => Boolean): Boolean Détection de tous les éléments. Par exemple: pour déterminer si tous les éléments de "H" au début: scala> l.forall (s => s.startsWith ( "H")) RES10: Boolean = false |
19 | def foreach (f: (A) => Unité): Unité Tous les éléments de la fonction à la liste |
20 | tête de def: A Obtenez le premier élément de la liste |
21 | def indexOf (elem: A, à partir de : Int): Int Trouver l'emplacement de la première occurrence de l'élément à l'emplacement spécifié à partir de |
22 | def INIT: Liste [A] Renvoie tous les éléments, sauf le dernier |
23 | def intersecter (ce qui suit: Seq [A ]): Liste [A] Calculer une pluralité de l'intersection d'ensembles |
24 | def isEmpty: Boolean Détecter si la liste est vide |
25 | def iterator: Iterator [A] Créer un nouveau iterator pour itérer les éléments |
26 | def dernière: A Retourne le dernier élément |
27 | def lastIndexOf (elem: A la fin: Int): Int A l'emplacement spécifié position finale commencer à chercher la dernière occurrence de l'élément |
28 | longueur de def: Int Retour à la longueur de la liste |
29 | carte def [B] (f: (A) => B): Liste [B] Grâce à une méthode donnée recalculera tous les éléments |
30 | def max: A Trouver l'élément maximal |
31 | def min: A Trouver le plus petit élément |
32 | def mkString: String Afficher une liste de tous les éléments sous forme de chaîne |
33 | def mkString (septembre: String): chaîne Séparateurs affiche une liste de tous les éléments sous forme de chaîne |
34 | inverser def: Liste [A] liste inversée |
35 | def triée [B>: A] : Liste [A] Liste tri |
36 | def startsWith [B] (que: Seq [B], offset: Int): Boolean Détecter si la liste contient la séquence spécifiée à l'emplacement spécifié |
37 | def somme: A Calcul et collection d'éléments |
38 | tail def: Liste [A] Renvoie tous les éléments, à l'exception de la première |
39 | prendre def (n: Int): Liste [A] Rapatrier les n premiers éléments de la liste |
40 | def takeRight (n: Int): Liste [A] n éléments extraits liste |
41 | def toArray: Array [A] Liste à un tableau |
42 | def toBuffer [B>: A] : Buffer [B] Retour tampon contient une liste de tous les éléments |
43 | def toMap [T, U]: Carte [T, U] Liste Carte converti |
44 | def toSeq: Seq [A] Liste convertir Seq |
45 | Toset def [B>: A] : Réglez [B] Liste convert Set |
46 | def toString (): String Converti à une liste de chaînes |
D' autres façons de se référer à la documentation de l' API