Scala学习文档-列表的使用
注：列表是不可变的，不能通过赋值改变列表的元素
列表具有递归结构，数组是连续的
scala里的列表类型是协变的？ --> scala中的逆变与协变
分治原则
//自定义实现:::操作符 def append[T](xs:List[T],ys:List[T]):List[T]={ xs match{ case List() => ys; case x::xs1 => x::append[T](xs1,ys); } }
//自定义实现reverse函数 def rev[T](xs:List[T]):List[T]={ xs match{ case List() => xs case x::xs1 => rev[T](xs1):::List(x) } }
前缀与后缀：drop、take、splitAt
xs take n 返回列表前n个元素
xs drop n 返回列表除了前n个元素之外的所有元素
xs splitAt n 在指定位置拆分列表
元素选择
在list中不常使用随机元素访问，因为xs(n)花费的时间与索引值n成正比。
显示列表
toString方法、mkString方法
转换列表
elements、toArray、copyToArray
val arr = abced.toArray //arr为数组 arr.toString arr.toList //数组转换为列表
List类的高阶方法
1.列表间映射 map, flatMap, foreach
li map fun：以类型为List[T]的列表xs和类型为T=>u的函数为操作元，返回把函数fun应用在li的每个元素之后由此组成的新列表
val l1 =List(1,2,3)map(_+1) //List(1,2,3)map(x=>x+1)
结果：res0: List[Int] = List(2, 3, 4)
val words = List("the","quick","brown","fox");
println(words.map(_.length))
结果：List(3, 5, 5, 3)
flatMap操作符与map类似，不过它的右操作符能够返回元素列表的函数，对列表每个元素调用该方法，然后连接所有方法的结果并返回
val words = List("the","quick","brown","fox");
println(words.map(_.toList))
println(words.flatMap(_.toList))
结果： List(List(t, h, e), List(q, u, i, c, k), List(b, r, o, w, n), List(f, o, x))
List(t, h, e, q, u, i, c, k, b, r, o, w, n, f, o, x)
foreach 右操作元是过程（返回类型是Unit的函数），只对每个列表元素都调用一遍过程，操作结果仍然是Unit，不产生结果列表
var sum:int=0 List.range(1,5).foreach(x=>sum=sum+x)
结果：没有返回值，但是sum=10
2.列表过滤
filter，partition， find， takeWhile， dropWhile， span
filter：返回列表中符合论断函数为true的所有元素组成的列表
List(1,2,3,4,5) filter(_%2==0)
结果：res0: List[Int] = List(2, 4)
partirion：返回列表中符合论断函数为false的所有元素组成的列表
find：返回列表中第一个符合论断函数为true的元素，返回为可选值
List(1,2,3,4,5)find(_%2==0)
结果：res0: Option[Int] = Some(2)
takeWhile，dropWhile：mylist takeWhile p 返回列表mylist中最长能够满足p的前缀，dropWhile移除mylist中能够满足p的前缀
span:作用相当于组合了takeWhile和dropWhile，返回一对列表。(和splitAt组合了take和drop一样)
List(1,2,3,4,-5,6,7) takeWhile(_>0) //结果：res1: List[Int] = List(1, 2, 3, 4) List(1,2,3,4,-5,6,7) dropWhile(_>0) //结果：res2: List[Int] = List(-5, 6, 7) List(1,2,3,4,-5,6,7) span (_>0) //结果：res3: (List[Int], List[Int]) = (List(1, 2, 3, 4),List(-5, 6, 7))
3.列表的论断：forall，exists
操作mylist forall p，如果列表的所有元素满足p，返回true
操作mylist exists p，如果列表中存在一个元素满足p，返回true
4.折叠列表 /：和:\
左折叠操作(z /: li)(op) 与三个对象有关 开始值z，列表li，以及二元操作op，折叠结果是op应用到前缀z以及每个相邻元素上
操作op必须以类型A和B的值为参数，并且返回类型为B的结果。 （z的类型为B，li的类型为A）
val z =1 val a =(z/:List(1,2,3)) (_+_) //相当于+(+(+(z,1),2),3) (z/:List(a,b,c)) (op) 等价于 op( op( op(z,a), b ), c )
结果a: Int = 7
右边折叠操作(List(a,b,c) :\z)(op) 等价于op(a , op(b , op(c , z ) ) )
5.列表排序sort
List(1,-4,5,9,6,8).sort(_<_)
words.sort(_.length>_.length)
List对象的方法
前面是List类的方法，因为是在类的对象上对这些方法进行调用
有些方法是定义在List类的伴生对象中的，其中一些是创建列表的工厂方法，一些是对特定类型列表的操作
1.通过元素创建列表：List.apply
List(1,2,3) 等价于List.apply(1,2,3)
2.创建数值范围
var li = List.range(1,5) // li =List(1,2,3,4) 尾部数值不在范围内
var li2 = List.range(1,9,2) //li2 =List(1,3,5,7,9) step数值作为第三参数
var li3 = List.range(9,1,-3) //li3 =List(9,6,3)
3.创建统一的列表 make
var li = List.make(3,"hello") // li = List(hello,hello,hello)
4.解除啮合列表 List.unzip
例子：
val li1 = List("a","b","c","d")
val li2 = List(1,2,3,4,5,6)
val s = li1.zip(li2) //zip把两个列表组合成对偶列表
println(s) //输出List((a,1), (b,2), (c,3), (d,4))
val (s1,s2) = List.unzip(s) //把对偶列表还原为两个列表 也可以用s.unzip，若s列表的元素不是列表，就不行。
println(s1) //输出List(a, b, c, d)
println(s2) //输出List(1, 2, 3, 4)
5.连接列表 List.flatten List.concat
flatten方法以列表内的列表作为参数，并且把所有的元素列表连接在一起。
concat方法连接多个元素列表，数目不限
var xss = List(List("a","b"),List("y","z"))
println(xss.flatten) //List(a, b, y, z)
println(List.concat(l1,l3)) //List(1, 2, 3, 4, 111, 52)
6.映射及测试配对列表 List.map2 List.forall2 List.exists2
scala2.11.4没有发现，近似功能函数待补充
