Les listes Scala sont similaires aux tableaux, tous leurs éléments ont le même type,
Mais ils sont également différents: la liste est immuable, une fois la valeur définie, elle ne peut plus être modifiée.
Deuxièmement, la liste a une structure récursive (c'est-à-dire la structure de la liste liée) alors que le tableau ne l'est pas.
La liste dans scala est une liste immuable. Parfois, il n'est pas pratique pour nous d'ajouter directement des objets. À ce stade, nous pouvons la convertir en liste java et l'ajouter, puis revenir en arrière.
LIst prend en charge l'ajout et la suppression rapides d'éléments dans l'en-tête, mais ne fournit pas la fonction d'accès rapide par pression vers le bas, qui nécessite un parcours linéaire des colonnes.
L'ajout et le retrait rapides de l'en-tête permettent une correspondance fluide des motifs
Si nous voulons stocker un objet dans une liste, parce que la liste n'est pas comme une liste java, nous pouvons l'ajouter directement.A ce moment, nous devons utiliser LIstBuffer.
LIstBuffer est une variable.
La liste fournit un accès rapide à la tête, mais un accès moins efficace à la queue. Liste pour ajouter des éléments, considérez généralement l'inverse, ajoutez des éléments, puis appelez reverset
Une autre alternative, en utilisant ListBuffer, fournit des opérations d'ajout et d'ajout à temps constant, et enfin appelle toList pour obtenir List.
Le code spécifique est le suivant:
val list = ListBuffer [ItemView] (). asJava
list.add ()
// Une fois l'ajout terminé, si vous souhaitez revenir à la liste scala, tout
commeScala directement list.asScala
1. Définition:
Deux méthodes 1. Construction List ()
2. Utilisation :: Construction nulle
par exemple:
var list1 = List(1,2,3)
list1.foreach(x => println(x))
println(list1(0),list1(2))
println("------change ele-----------")
//list1(0) = 9999 //error : value update is not a member of List[Int]
println(list1(0))
Sortir:
PS: Si vous stockez différents types de données dans la liste, le type de liste deviendra Any
2. Liste des épissures
Deux méthodes ::: et List.concat ()
par exemple:
var list1 = List(1)
var list2 =List(2)
//method 1
var list3 = list1:::list2
//method 2
var list4 = List.concat(list1, list2)
list3.foreach(x => println(x))
list4.foreach(x => println("list4: "+x))
Sortir:
3. Énumérer les méthodes courantes
Opérations courantes de ListBuffer
map [B] (f: (A) => B): Liste [B]
Recalculer tous les éléments par la méthode donnée
par exemple:
val lb = new ListBuffer[String]
lb.append("张三","李四","王五","赵四"," ","张三")
var list2 = lb.map(x => x.trim+"2333")
list2.foreach(x => println(x))Sortir:
max: A
Trouvez le plus grand élément
min: A
Trouvez le plus petit élément
par exemple:
var lb = new ListBuffer[Int]
lb.append(1,2,3,4,5)
var x = lb.max
println(x)
println("----------------")
var n = lb.min
println(n)
inverse: Liste [A]
Liste inversée
trié
| def trié [B>: A]: Liste [A] Tri de liste
Version détaillée: https://blog.csdn.net/hzp666/article/details/115086159 |
3.1 Augmentation:
ajouter()
var lb = new ListBuffer[Int]
lb.append(1)
lb.append(2,3,4)
lb.foreach(x => println(x))
输出：
1
2
3
4
3.2删| drop (n: Int): Liste [A] Supprimer les n premiers éléments et renvoyer une nouvelle liste |
par exemple:
var lb = new ListBuffer[Int]
lb.append(1,2,3,4)
var listTem = new ListBuffer[Int]
listTem = lb.drop(2) //d
listTem.foreach(x => println(x))Sortir:
dropRight (n: Int): Liste [A]
Supprimer les n derniers éléments et renvoyer une nouvelle liste
eg:
var lb = new ListBuffer[Int]
lb.append(1,2,3,4)
var listTem = new ListBuffer[Int]
listTem = lb.dropRight(2)
listTem.foreach(x => println(x))Sortir:
dropWhile (p: (A) => Booléen): Liste [A]
Jeter les éléments de gauche à droite jusqu'à ce que la condition p ne soit pas satisfaite
var lb = new ListBuffer[Int]
lb.append(1,2,3,4,5)
var lbTemp = new ListBuffer[Int]
var len = lb.length
lbTemp = lb.dropWhile(len => len<3 )
lbTemp.foreach(x => println(x))Sortir:
existe (p: (A) => Booléen): Booléen
Déterminez si l'élément de la condition spécifiée dans la liste existe.
Déterminez s'il y a un élément dans l:
par exemple:
val listString = new ListBuffer[String]
listString.append("张三","李四","麻子","赵四"," ")
var flag:Boolean = listString.exists(x => x.equals("zhangsan"))
val flag2 = listString.exists(x => x.equals("赵四"))
println("flag :"+flag)
println("flag2 :"+flag2)
Sortir:
forall (p: (A) => Boolean): Booléen
Vérifiez tous les éléments.
Par exemple: pour déterminer si tous les éléments commencent par "H":
scala> l.forall (s => s.startsWith ("H")) res10: Boolean = false
3,3
3.4 Requête
Selon la requête en indice:
var lb = new ListBuffer[Int]
lb.append(1)
lb.append(2,3,4)
println(lb.apply(1))Sortir:
2
indexOf (elem: A, from: Int): Int
Recherchez la première occurrence de l'élément à partir de la position spécifiée à partir de
Impossible de trouver le retour -1
par exemple:
val lb = new ListBuffer[String]
lb.append("张三","李四","王五","赵四"," ")
var index1 = lb.indexOf("张三")
println(index1)
println("------------------")
var index2 = lb.indexOf("张三1")
println(index2)Sortir:
lastIndexOf (elem: A, end: Int): Int
Commencez à rechercher la dernière position de l'élément à l'extrémité de position spécifiée
eg:
val lb = new ListBuffer[String]
lb.append("张三","李四","王五","赵四"," ","张三")
var index = lb.lastIndexOf("张三")
println(index)Sortir:
longueur: Int
Longueur de la liste de retour
| Numéro de série | Méthode et description |
|---|---|
| 1 | def + :( elem: A): Liste [A] Pré-ajouter des éléments à la liste |
| 2 | def: :( x: A): Liste [A] Ajouter des éléments au début de la liste |
| 3 | def :: :( préfixe: Liste [A]): Liste [A] Ajouter l'élément de la liste spécifiée au début de la liste |
| 4 | def: + (elem: A): Liste [A] Copiez la liste après avoir ajouté des éléments. |
| 5 | def addString(b: StringBuilder): StringBuilder 将列表的所有元素添加到 StringBuilder |
| 6 | def addString(b: StringBuilder, sep: String): StringBuilder 将列表的所有元素添加到 StringBuilder，并指定分隔符 |
| 7 | def apply(n: Int): A 通过列表索引获取元素 |
| 8 | def contains(elem: Any): Boolean 检测列表中是否包含指定的元素 |
| 9 | def copyToArray(xs: Array[A], start: Int, len: Int): Unit 将列表的元素复制到数组中。 |
| 10 | def distinct: List[A] 去除列表的重复元素，并返回新列表 |
| 11 | def drop(n: Int): List[A] 丢弃前n个元素，并返回新列表 |
| 12 | def dropRight(n: Int): List[A] 丢弃最后n个元素，并返回新列表 |
| 13 | def dropWhile(p: (A) => Boolean): List[A] 从左向右丢弃元素，直到条件p不成立 |
| 14 | def endsWith[B](that: Seq[B]): Boolean 检测列表是否以指定序列结尾 |
| 15 | def equals(that: Any): Boolean 判断是否相等 |
| 16 | def exists(p: (A) => Boolean): Boolean 判断列表中指定条件的元素是否存在。 判断l是否存在某个元素: |
| 17 | def filter(p: (A) => Boolean): List[A] 输出符号指定条件的所有元素。 过滤出长度为3的元素: |
| 18 | def forall(p: (A) => Boolean): Boolean 检测所有元素。 例如：判断所有元素是否以"H"开头： scala> l.forall(s => s.startsWith("H")) res10: Boolean = false |
| 19 | def foreach(f: (A) => Unit): Unit 将函数应用到列表的所有元素 |
| 20 | def head: A 获取列表的第一个元素 |
| 21 | def indexOf(elem: A, from: Int): Int 从指定位置 from 开始查找元素第一次出现的位置 |
| 22 | def init: List[A] 返回所有元素，除了最后一个 |
| 23 | def intersect(that: Seq[A]): List[A] 计算多个集合的交集 |
| 24 | def isEmpty: Boolean 检测列表是否为空 |
| 25 | def iterator: Iterator[A] 创建一个新的迭代器来迭代元素 |
| 26 | def last: A 返回最后一个元素 |
| 27 | def lastIndexOf(elem: A, end: Int): Int 在指定的位置 end 开始查找元素最后出现的位置 |
| 28 | def length: Int 返回列表长度 |
| 29 | def map[B](f: (A) => B): List[B] 通过给定的方法将所有元素重新计算 |
| 30 | def max: A 查找最大元素 |
| 31 | def min: A 查找最小元素 |
| 32 | def mkString: String 列表所有元素作为字符串显示 |
| 33 | def mkString(sep: String): String 使用分隔符将列表所有元素作为字符串显示 |
| 34 | def reverse: List[A] 列表反转 |
| 35 | def sorted[B >: A]: List[A] 列表排序
|
| 36 | def startsWith[B](that: Seq[B], offset: Int): Boolean 检测列表在指定位置是否包含指定序列 |
| 37 | def sum: A 计算集合元素之和 |
| 38 | def tail: List[A] 返回所有元素，除了第一个 |
| 39 | def take(n: Int): List[A] 提取列表的前n个元素 |
| 40 | def takeRight(n: Int): List[A] 提取列表的后n个元素 |
| 41 | def toArray: Array[A] 列表转换为数组 |
| 42 | def toBuffer[B >: A]: Buffer[B] 返回缓冲区，包含了列表的所有元素 |
| 43 | def toMap[T, U]: Map[T, U] List 转换为 Map |
| 44 | def toSeq: Seq[A] List 转换为 Seq |
| 45 | def toSet[B >: A]: Set[B] List 转换为 Set |
| 46 | def toString(): String 列表转换为字符串 |