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

上一篇:redis/分布式文件存储系统/数据库 存储session,解决负载均衡集群中session不一致问题


下一篇:yii CMenu的配置(导航栏)