本章主要分析Scala中List的用法，List上可进行的操作，以及需要注意的地方。
一、List字面量
首先看几个List的示例。
val fruit = List("apples", "oranges", "pears")
val nums = List(1, 2, 3, 4)
val diag3 =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
val empty = List() 代码运行结果略。
与arrays不同的是，List是imutable的，即List中的元素不能被修改。其次List具有递归结构，比如linked list，而arrays是连续的。
有关List中的元素不能被修改，可以看下面代码。
fruit = "banana" 运行结果：
二、List类型
List变量中的元素都有相同的类型，比如List[T]表示该List对象中所有元素的类型都是T，可以在定义变量时加一个显示的类型声明，如下所示
val fruit: List[String] = List("apples", "oranges", "pears")
val nums: List[Int] = List(1, 2, 3, 4)
val diag3: List[List[Int]] =
List(
List(1, 0, 0),
List(0, 1, 0),
List(0, 0, 1)
)
val empty: List[Nothing] = List() 运行结果略。
List类型是协变的。即，如果S是T的子类，那么List[S]是List[T]的子类。
三、构造List对象
List对象由两个关键字生成，一个是Nil另一个是::。其中Nil代表空的list，::操作符表示将该元素追加到list的前面。所以，前面的代码还可以写成
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))
val diag3 = (1 :: (0 :: (0 :: Nil))) ::
(1 :: (0 :: (0 :: Nil))) ::
(1 :: (0 :: (0 :: Nil))) :: Nil
val empty = Nil ::操作符从后往前匹配，即A :: B :: C等价于A :: (B :: C)，所以，对上面代码中的变量fruit可以写成
val fruit = "apples" :: "oranges" :: "pears" :: Nil四、List上的基本操作
List上的所有操作，底层都可以表示成以下三个： head：获取list中的第一个元素 tail：获取list中除了第一个元素之外的其他元素组成的新list isEmpty：如果当前list为空，返回true
需要注意的是head和tail方法只能作用在非空list上，否则会报错，如下所示
Nil.head 结果如下，
下面使用者三个方法，实现一个List[Int]类型变量的插入排序代码（升序）。
def isort(xs: List[Int]): List[Int] =
if (xs.isEmpty) Nil
else insert(xs.head, isort(xs.tail))
def insert(x: Int, xs: List[Int]): List[Int] =
if (xs.isEmpty || x <= xs.head) x :: xs
else xs.head :: insert(x, xs.tail) 在方法isort中，如果xs为空，直接返回Nil，否则将xs的第一个元素xs.head调用insert方法插入到xs.tail中。
在方法insert中，如果待插入的xs为空，或者待插入变量x比xs的第一个元素还小，则直接插在xs前面。否则将xs的第一个元素放在最前面，继续排列x和xs除第一个元素之外的其他元素。
五、List模式
List也可以作用在模式匹配的情况下。比如下面代码
val List(a, b, c) = fruit 运行结果如下，直接将fruit中的内容依次赋给变量a, b, c。
使用上面的代码，表示明确知道fruit变量中的元素个数为3。否则会出现元素个数不匹配的报错，如下
val List(x, y) = fruit 运行结果如下，
这时如果仍然想要使用模式匹配，可以使用::操作符，如下所示
val a :: b :: c = fruit
val a :: b :: c :: d = fruit
val a :: b :: c :: d :: e = fruit 运行结果如下，会将fruit变量中的第一个元素赋给变量a，第二个元素赋给b，然后将剩下的以List形式赋给变量c。
但是可赋值的变量个数不能超过List中的元素个数加一，在这种情况下最后一个变量d的内容为一个空的List。
如果变量个数超过List中的元素个数加一，就会报错。
使用这个特性改造一下插入排序代码。
def isort(xs: List[Int]): List[Int] = xs match {
case List() => List()
case x :: xs1 => insert(x, isort(xs1))
}
def insert(x: Int, xs: List[Int]): List[Int] = xs match {
case List() => List(x)
case y :: ys => if (x <= y) x :: xs
else y :: insert(x, ys)
} isort方法中，如果传入的xs是一个空List直接返回一个空List，否则，将第一个元素赋值给变量x，调用insert方法插入到剩余元素组成的xs1中。
insert方法中，如果待插入的xs为空，直接返回包含一个元素的List。否则，比较待插入元素x和xs的第一个元素y的大小，将值小的放在前面，组成一个新的List。
六、List上的一阶操作(First-order)
1、:::操作符，合并两个List对象
:::操作符作用于两个List对象上，xs ::: ys表达式的结果是得到一个新的List对象，该对象包含xs和ys中的全部元素，并且xs在前。
List(1, 2) ::: List(3, 4, 5)
List() ::: List(1, 2, 3)
List(1, 2, 3) :: List(4) 运行结果如下，
:::操作符和::类似，也是从右向左执行的。所以xs ::: ys ::: zs等价于xs ::: (ys ::: zs)
2、使用分治原则自定义:::功能
前面已经看到了Scala中实现了连接两个List对象的操作:::，如果想要手动实现该功能，比如定义一个append方法，作用与:::相同，应该怎么做？
首先看一下append方法的定义，
def append[T](xs: List[T], ys: List[T]): List[T] 接下来使用分治策略来实现该方法的方法体。前面可以看到，使用List模式匹配能够将一个List对象划分成单个元素或者子List的情况。
def append[T](xs: List[T], ys: List[T]): List[T] =
xs match {
case List() =>
case x :: xs1 =>
} 对于第一个分支，如果xs为空，那么直接返回ys即可，即
case List() => ys对于第二个分支，则继续将其切割成小的元素，
def append[T](xs: List[T], ys: List[T]): List[T] =
xs match {
case List() => ys
case x :: xs1 => x :: append(xs1, ys)
}3、length方法，获取list中元素个数
length方法，获取当前list的长度。所谓长度，是指当前list中有多少个元素。对于List来说，计算其长度，是一个比较耗费时间的操作，时间复杂度与List中的元素个数成正比，因为需要遍历其中每一个元素才能得到List的长度。
所以，xs.isEmpty比xs.length == 0的效率高，虽然两者的作用是相同的。
下面看一个示例，
List(1, 2, 3).length 结果如下，
4、init和last方法，访问List的尾部
对应前面的head方法，List上有一个last方法，用于访问该list中最后一个元素。如下所示，
List('a', 'b', 'c', 'd', 'e').last 对应于tail方法，init方法获取除去最后一个元素之外其他元素组成的新的List对象，如下所示，
List('a', 'b', 'c', 'd', 'e').init 运行结果如下，
需要注意的是，这两个方法不能作用于空的List上，否则会报错。并且，init和last方法会比tail和head方法是效率低，因为操作List后面的元素，需要遍历整个List对象才能实现。因此，在生成List对象时，最好将经常访问的元素置于List前面。
5、reverse方法，翻转List中的元素顺序
该方法会将List中的元素顺序翻转得到一个与原List顺序相反的新List对象，而不改变之前那个List对象的内容，如下所示，
val abcde = List('a', 'b', 'c', 'd', 'e')
abcde.reverse 运行结果如下，
将reverse方法和前面的init, last, head, fail方法结合，有以下一些规律：
- xs.reverse.reverse结果为xs
- xs.reverse.init结果为xs.tail.reverse
- xs.reverse.tail结果为xs.init.reverse
- xs.reverse.head结果为xs.last
- xs.reverse.last结果为xs.head
6、drop，take和splitAt方法，前缀和后缀
take方法，xs take n返回xs对象的前n个元素，形成一个新的List对象。
drop方法，xs drop n返回xs对象除了前n个元素之外的其他元素组成的新List对象。
abcde take 2
abcde drop 2 结果如下，
而splitAt方法，xs splitAt n表示从n个元素处，将xs分割成两个List对象。等价于xs take n, xs drop n。
abcde splitAt 2
val (x, y) = abcde splitAt 2 运行结果如下，
7、apply方法和下标，获取指定元素
List也可以使用下标访问指定元素abcde(2)List对象的apply`方法，等价于上面所示的访问指定位置的元素，所以下面代码和上面的是等价的
abcde apply 2 运行结果如下，
indicies方法，获取当前List对象中所有元素的下标，
abcde.indices 运行结果如下，
8、flatten方法，展平List[List]对象中的所有元素
这个方法可以将List[List]结构的对象中所有元素展开，返回一个包含所有子List元素的新的List对象，如下，
List(List(1, 2), List(3), List(), List(4, 5)).flatten 运行结果如下，
注意，该方法只能应用于List[List]的对象上，直接由List对象调用，会报错
List(1, 2, 3).flatten 结果如下，
9、zip和unzip方法，组合两个list对象为pairs形式
直接看示例吧。
abcde.indices zip abcde 结果如下，将前一个List对象的每一个元素与后一个List对象的每一个元素组合成pairs。
如果前后两个List对象长度不一致，将会返回较短长度的那个结果，
abcde zip List(1, 2, 3)
List(1, 2, 3) zip abcde 结果如下，
在这里还有一个特殊的方法zipWithIndex，作用是将该List对象中的每一个元素与其下标进行zip操作。
abcde.zipWithIndex 运行结果如下，
unzip方法的作用与zip方法相反，将一个pairs形式的List拆分成两个List对象，
val zipped = abcde zip List(1, 2, 3)
zipped.unzip 运行结果如下，
10、toString和mkString方法，将list中元素拼接成字符串
toString方法略。
mkString方法可以传入一个连接符，用该连接符将List对象中的各个元素拼接起来最终形成一个字符串。也可以指定其前缀和后缀。
abcde mkString "-"
abcde mkString ("[", "-", "]") 运行结果如下，
11、iterator， toArray和copyToArray方法，转换List对象类型
（1）List与Array互转
List对象转为Array，
val arr = abcde.toArray Array转List，
arr.toList 运行结果如下，
（2）copyToArray方法
该方法可以将List对象中的元素复制到指定Array对象的指定位置，比如下面代码中，将List(1, 2, 3)中的三个元素插入到arr2对象的第3~5位置上。然后arr2这个Array中的元素个数和内容发生变化。
val arr2 = new Array[Int](10)
List(1, 2, 3) copyToArray (arr2, 3) 运行结果如下，
（3）inerator方法
获得当前List对象的迭代器，可以用此迭代器访问下一个元素。
val it = abcde.iterator
it.next
it.next 运行结果如下，
七、List上的高阶操作(Higher-order)
1、map, flatMap, foreach方法，处理List中的每个元素
（1）map方法
map方法接收一个函数参数，将该函数作用在List的每一个元素上，得到的结果组合成一个新的List对象。
List(1, 2, 3) map (_ + 1)
val words = List("the", "quick", "brown", "fox")
words map (_.length)
words map (_.toList.reverse.mkString) 运行结果如下，
（2）flatMap方法
和map方法有点类似，区别在于flatMap方法接收到的函数对单一元素作用后得到多个结果，会将这些结果返回到一个List对象中。和前面的flatten方法有点类似。
words map (_.toList)
words flatMap (_.toList) 运行结果如下，传入的方法是将当前元素拆分成List对象，所以一个元素经过map后会返回一个List对象，最终形成List[List]的结构。但是flatMap方法会将map得到的每一个List打散，取出其中每一个元素，组合成一个新的List对象并返回。
（3）foreach方法
该方法和map方法类似，也是接收一个函数参数，这个函数参数会作用在List中的每一个元素上。但是这个函数的返回值为Unit，所以其副作用仅仅是比如打印其中的每一个元素，或者改变某个变量的值，比如下面例子中的求和。
List(1, 2, 3, 4, 5) foreach (println)
var sum = 0
List(1, 2, 3, 4, 5) foreach (sum += _) 运行结果如下，
2、filter, partition, find, takeWhile, dropWhile, span方法，过滤List中的元素
（1）filter方法
传入一个函数参数，最终得到一个新的List对象，包含原List中使该函数参数值为true的元素。
List(1, 2, 3, 4, 5) filter (_ % 2 == 0) // 返回所有偶数
words filter (_.length == 3) // 返回所有字符长度为3的元素 运行结果如下，
（2）partition方法
该方法是filter方法的加强版。filter只会返回时函数参数值为true的一个新List。而partition方法，会同时返回两个List，第一个为函数参数为true的所有元素，第二个为函数参数为false的所有元素。
List(1, 2, 3, 4, 5) partition (_ % 2 == 0) 运行结果如下，
（3）find方法
和filter方法类似，但是find方法只返回List中第一个满足该函数表达式的元素，而不是返回一个List对象。返回值类型为Some(x)或者None。
List(1, 2, 3, 4, 5) find (_ % 2 == 0)
List(1, 2, 3, 4, 5) find (_ <= 0) 运行结果如下，
（4）takeWhile方法
xs takeWhile p获取xs中最前面的所有满足p表达式的元素。
List(1, 2, 3, -4, 5) takeWhile (_ > 0) 运行结果如下，直到遇到-4时不满足该表达式，尽可能长的从第一个元素取满足该表达式的元素。
（5）dropWhile方法
和takeWhile方法正好相反，尽可能的从第一个元素删除所有满足表达式的元素。
List(1, 2, 3, -4, 5) dropWhile (_ > 0) 运行结果如下，
（6）span方法
是takeWhile和dropWhile两个方法的结合形式。有点类似于splitAt方法综合了take和drop方法一样。
xs span p等价于xs takeWhile p, xs dropWhile p。
List(1, 2, 3, -4, 5) span (_ > 0) 运行结果如下，
3、forall, exists方法，判断满足条件元素是否存在
xs forall p，其中xs是一个List类型对象，p是一个判断表达式，只有当xs中每一个元素均使p的结果为true时，整个结果才返回true。而xs exists p表示xs中只要存在任意一个元素使p的结果为true，整个结果返回true。
val diag3 = (1 :: 0 :: 0 :: Nil) ::
(0 :: 1 :: 0 :: Nil) ::
(0 :: 0 :: 1 :: Nil) :: Nil
def hasZeroRow(m: List[List[Int]]) =
m exists (row => row forall (_ == 0))
hasZeroRow(diag3) 上面代码遍历diag3变量，如果diag3中某个子List的值全部为0，则结果为true。运行结果如下
4、/:, :\方法，折叠List
所谓的折叠List即对List中的元素进行汇总。比如说如果有一个函数sum(List(a, b, c))接收一个List参数，然后将该List中各元素的和进行累加，最终得到一个和，这个过程就可以称为对List的折叠。
Scala中提供了两个方法实现折叠功能
（1）/:方法，左折叠
对于左折叠，完整的调用形式是(z /: xs) (op)，包含三个部分，其中z是一个初始值，xs是一个List对象，op是一个二元操作表达式。最终结果是将表达式op从z开始，依次从左到右的遍历xs中的每个元素。
(z /: List(a, b, c)) (op) 等价于 op(op(op(z, a), b), c) 用图表示的话，如下所示，
下面举个例子，
val words = List("the", "quick", "brown", "fox")
("" /: words) (_ + " " + _) 运行结果如下，最终返回一个字符串
（2）:\方法，右折叠
右折叠与左折叠功能类似，只不过是从右往左遍历List中的元素。
(List(a, b, c) :\ z) (op) 等价于 op(a, op(b, op(c, z))) 用图表示，
最后，用左折叠定义一个求数组和的方法，
def sum(xs: List[Int]): Int =
(0 /: xs) (_ + _)
sum(List(1, 2, 3)) 运行结果如下，
5、sortWith方法，排序List中的元素
xs sortWith before表达式中，xs是一个List对象，before是一个可用比较两个元素值的函数表达式。这个表达式的含义是，对xs中的元素进行排序，根据before方法来确定xs中哪个元素在前，哪个元素在后。
List(1, -3, 4, 2, 6) sortWith (_ < _)
words sortWith (_.length > _.length) 运行结果如下，
八、List对象上的方法
1、List.apply方法，使用传入的元素生成List对象
根据给定元素生成一个新的List对象。
List.apply(1, 2, 3) 结果，
2、List.range方法，生成包含范围内值的List
给定一个范围，根据起始值或者阶跃单位量生成一个List对象，
List.range(1, 5) // 从1到5
List.range(1, 9, 2) // 从1到9，每隔2生成一个元素
List.range(9, 1, -3) // 从9到1，每个-3生成一个元素 运行结果如下，
3、List.fill方法，根据给定元素和个数生成List
示例，
List.fill(5)('a') // 生成一个List对象，其中的元素为5个a字符
List.fill(3)("hello") // 生成一个List对象，其中元素为3个hello字符串
List.fill(2, 3)('b') // 也可以生成多维List，这里展示一个二维 运行结果如下，
4、List.tabulate方法，根据给定维度动态生成List元素值
该方法与List.fill有点类似，也是传入两个参数列表，第一个仍然是维度及长度，第二个参数列表中传入一个函数表达式而不是List.fill中那样传入一个固定值。这样，List.tabulate方法中的元素值就是动态变化的，由第二个参数列表中的表达式计算得到，改表达式的输入参数为当前元素的下标值。
val xs = List.tabulate(5)(n => "xs" + n) // 在每个下标前拼接一个xs
val squares = List.tabulate(5)(n => n * n) // 每个元素取其下标的平方值
val multiplication = List.tabulate(5, 5)(_ * _) // 每个元素取其纵横下标的乘积 运行结果如下，
5、List.concat方法，拼接多个List
将多个List对象中的元素拼接到一起，可以拼接元素类型不同的List对象，形成一个新的List对象。类似于前面的flatten方法。
List.concat(List('a', 'b'), List('c'))
List.concat(List('a', 'b'), List(1))
List.concat() 运行结果如下，
九、zipped方法，处理多个List对象
通过前面介绍的zip方法，可以将两个List对象组合到一起，形成元素为pairs对的新List对象。Scala中还提供了一个zipped方法，在该方法之后就可以同时处理两个List对象中的元素了。
(List(10, 20), List(3, 4, 5)).zipped.map(_ * _) 运行结果如下，map方法中的两个_分别表示第一个和第二个List对象中对应位置上的元素。
zipped方法后，还可以使用forall或者exists方法，如下所示
(List("abc", "de"), List(3, 2)).zipped.forall(_.length == _)
(List("abc", "de"), List(3, 2)).zipped.exists(_.length != _) 运行结果如下，
这里需要注意的是zipped方法，只取较短那个List的长度，超过该长度的长List中的元素会被丢弃。