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.csdn.net/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))

输出：

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] 为列表预添加元素 `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] 在列表开头添加元素
3	def :::(prefix: List[A]): List[A] 在列表开头添加指定列表的元素
4	def :+(elem: A): List[A] 复制添加元素后列表。 `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 将列表的所有元素添加到 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是否存在某个元素: `scala> l.exists(s => s == "Hah") res7: Boolean = true`
17	def filter(p: (A) => Boolean): List[A] 输出符号指定条件的所有元素。过滤出长度为3的元素: `scala> l.filter(s => s.length == 3) res8: List[String] = List(Hah, WOW)`
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.csdn.net/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 列表转换为字符串

Scala中的列表List