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没有发现，近似功能函数待补充