本文深入探讨Scala中的列表概念，包括其特点、构造方式、拼接方法以及常用的列表操作，如增删查改等，并通过示例代码展示如何使用列表。
Scala 列表类似于数组，它们所有元素的类型都相同，
但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，
其次列表 具有递归的结构（也就是链接表结构）而数组不是。
scala中的list是一个不可变的列表,有时候我们想直接添加对象不太方便,这个时候可以先转成java的List添加完再转回去.
LIst支持在头部快速添加和移除条目，但是不提供快速按下标访问的功能，这个功能需要线性遍历列。
快速的头部添加和移除意味着模式匹配很顺畅
如果我们想要往一个list里面存一个object,因为list不像java的list,可以直接add进行.这个时候我们需要用LIstBuffer.
LIstBuffer是一个可变的.
List提供头部快速访问，对尾部访问则没那么高效。List追加元素，通常考虑反过来，追加元素，再调用reverset
另一个可选方案，使用ListBuffer，提供了常量时间的往后追加和往前追加的操作，最后调用toList获取List。
具体的代码如下:
val list = ListBuffer[ItemView]().asJava
list.add()
//添加完成后,如果想要转回scala的list,直接asScala就行了
list.asScala
1.定义：
两种方法 1. List() 构造
2. 使用 :: Nil 构造
eg：
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))
输出：
PS：如果在list中 存储不同类型 数据，list类型将变为Any
2.列表拼接
两种方法 ::: 和 List.concat()
eg:
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))
输出：
3.list常用方法
ListBuffer 的常用操作
map[B](f: (A) => B): List[B]
通过给定的方法将所有元素重新计算
eg:
val lb = new ListBuffer[String]
lb.append("张三","李四","王五","赵四"," ","张三")
var list2 = lb.map(x => x.trim+"2333")
list2.foreach(x => println(x))输出：
max: A
查找最大元素
min: A
查找最小元素
eg:
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)
reverse: List[A]
列表反转
sorted排序
| def sorted[B >: A]: List[A] 列表排序
详细版：https://blog.youkuaiyun.com/hzp666/article/details/115086159 |
3.1增：
append()
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): List[A] 丢弃前n个元素，并返回新列表 |
eg:
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))输出：
dropRight(n: Int): List[A]
丢弃最后n个元素，并返回新列表
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))输出：
dropWhile(p: (A) => Boolean): List[A]
从左向右丢弃元素，直到条件p不成立
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))输出：
exists(p: (A) => Boolean): Boolean
判断列表中指定条件的元素是否存在。
判断l是否存在某个元素:
eg:
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)
输出：
forall(p: (A) => Boolean): Boolean
检测所有元素。
例如：判断所有元素是否以"H"开头：
scala> l.forall(s => s.startsWith("H")) res10: Boolean = false
3.3
3.4查询
根据下标查询：
var lb = new ListBuffer[Int]
lb.append(1)
lb.append(2,3,4)
println(lb.apply(1))输出：
2
indexOf(elem: A, from: Int): Int
从指定位置 from 开始查找元素第一次出现的位置
找不到 返回 -1
eg:
val lb = new ListBuffer[String]
lb.append("张三","李四","王五","赵四"," ")
var index1 = lb.indexOf("张三")
println(index1)
println("------------------")
var index2 = lb.indexOf("张三1")
println(index2)输出：
lastIndexOf(elem: A, end: Int): Int
在指定的位置 end 开始查找元素最后出现的位置
eg:
val lb = new ListBuffer[String]
lb.append("张三","李四","王五","赵四"," ","张三")
var index = lb.lastIndexOf("张三")
println(index)输出：
length: Int
返回列表长度
| 序号 | 方法及描述 |
|---|---|
| 1 | def +:(elem: A): List[A] 为列表预添加元素 |
| 2 | def ::(x: A): List[A] 在列表开头添加元素 |
| 3 | def :::(prefix: List[A]): List[A] 在列表开头添加指定列表的元素 |
| 4 | def :+(elem: A): List[A] 复制添加元素后列表。 |
| 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] 列表排序
详细版：https://blog.youkuaiyun.com/hzp666/article/details/115086159 |
| 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 列表转换为字符串 |
扫一扫
1316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
