scala学习（6）

列表

不可变，在声明时必须初始化

列表头部和尾部：head和tail

head返回第一个值，tail返回除第一个元素外的值构成的新列表

val s = List(1,2,3,4,5)
s.head
s.tail
val a = "hh"::s #在已有列表前端添加元素，右结合：：，原列表对象不变
val b = 1::2::3::Nil #Nil是空列表对象
val b = List(1,2,3)
s.size
s.head//返回第一个元素
s.tail//返回除第一个元素外的所有元素
s(2)
val numbers = List(32,95,24,21,17)
var total = 0;for (i <- numbers) {total += i}
//高阶函数
val colors = List("red","green","blue")
colors.foreach((c:String) => println(c)) //取一个函数，对列表中的每一项分别调用这个函数
val sizes = colors.map((c:String) => c.size)//取一个函数，将一个列表元素转换为另一个值或类型
val total = numbers.reduce((a:Int,b:Int) => a+b) //取一个函数，将两个列表元素结合为一个元素。

val colors = List("red", "green", "blue")
val oddsAndEvents = List(List(1,3,5), List(2,4,6))
val keyValues = List(("A","65"),("B",66),('C',67))
val primes = List(2,3,4,7,11,13)
val first = primes(0)
val fourth = primes(3)
val first = primes.head
val remaining = primes.tail
//while循环构建的迭代器
var i = primes
while(! i.isEmpty) {print(i.head+",");i = i.tail}]
//递归形式
def visit(i:List[Int]) {if (i.size > 0) {println(i.head+",");
                                        visit(i.tail)}}
visit(primes)
//所有的列表都有一个Nil实例作为终结点
val primes =List(2,3,5,7,11,13)
var i = primes
while(i !=Nil) {println(i.head+",");i = i.tail}
//创建一个空列表实际返回Nil而不是一个新实例，Nil是不可变得。
val l:List[Int] = List()
l == Nil
val m :List[String] = List("a")
m.head;m.tail
m.tail == Nil

Cons操作符

利用和Nil得关系，可以采用另一种方法构造列表。使用cons（construct得简写）操作符来构建列表。

val numbers =1::2::2::3::Nil //元素
val first = Nil.::(1)
first.tail ==Nil //true
val second = 2::first //元素和列表
second.tail == first//true
val 
val third = first:::second //均为列表

方法名	示例	描述
::	1::2::Nil	为列表追加单个元素。是一个右结合操作符
:::	List(1,2):::List(2,3)	在列表前面追加另一个列表。右结合
++	List(1,2) ++Set(3,4,3)	为列表追加另一个集合
==	List(1,2) ==List(1,2)	如果集合类型和内容都相同，返回true
distinct	List(3,5,4,3,4).distinct	返回不包含重复元素得列表版本。
drop	List("a",'b','c','d') drop 2	从列表中去除前n个元素
filter	List(23,8,14,21) filter(_ >18)	从列表返回经过一个true/false函数验证的元素
flatten	List(List(1,2),List(3,4)).flatten	将一个列表的列表转换为元素列表
partition	List(1,2,3,4,5) partition(_ < 3)	根据一个true/false函数的结果，将元素分组为由两个列表构成的一个元组
reverse	List(1,2,3).reverse	逆置列表
slice	List(2,3,5,7) slice(1,3)	返回列表的一部分，从第一个索引直到第二个索引（但不包括第二个 ）
sortBy	List("apple","to") sortBy(_.size)	按给定函数返回的值对列表排序
sorted	List("apple","to").sorted	按自然值对核心scala类型的列表排序
splitAt	List(2,3,5,7) splitAt 2	根据位于一个给定索引前面还是后面将元素分组为由两个列表构成的元组
take	List(2,3,5,7,11,13) take 3	从列表抽取前n个元素
zip	List(1,2) zip List("a","b")	将列表合并为一个元组列表，每个元组包含两个列表中各个索引的相应元素

操作符记法：list drop 2

点记法：list.flatten

高阶函数：

sortBy，指定一个函数，返回一个值，用来对列表中得元素排序。

filter和partition分别取一个谓词函数（得到一个输入值后相应返回true/false）

:,take,drop在列表前面完成操作，不存在性能损失。List在前面增加和删除项不需要遍历整个列表。但是这些操作得反向操作将作用于列表末尾，就需要完整得遍历列表。

//反向操作
val appended = List(1,2,3,4) :+ 5
val suffix = appended takeRight 3
val middle = suffix dropRight 2

规约列表

把列表收缩为单个值。

数学规约

操作名	示例	描述
max	List(41,59,26).max	最大值
min	List(10.9,32.5,4.23,5.67).min	最小值
product	List(5,6,7).product	相乘
sum	List(11.3,23.5,7.2).sum	求和

布尔规约

操作	示例	描述
contains	List(34,29,18) contains 29	是否包含
endsWith	List(0,4,3) endsWith List(4,3)	是否以结尾
exists	List(24,17,32) exists (_ < 18)	检查一个谓词是否至少对列表中得一个元素返回true
forall	List(24,17,32) forall (_ < 18)	检查一个谓词是否至少对列表中得每一个元素返回true
startsWith	List(0,4,3) startsWith List(0)	测试列表是否以一个给定得列表开头

val a = List(true,true,false,true)
val a1 = !(a contains false)
val a2 = a forall (_ == true)
val a3 = a.exists(_ == false) ==false
//自己创建一个规约
def contains(x:Int,l:List[Int]):Boolean = {
    var a:Boolean = false
    for (i<- l) {if (!a) a = (i == x)}
    a
}
val inclued = contains(19,List(46,19,92))

操作	示例	描述
fold	List(4,5,6).fold(0)(_ + _)	给定一个起始值和一个规约函数来规约列表
foldLeft	List(4,5,6).foldLeft(0)(_ + _)	给定一个起始值和一个规约函数从左到右来规约列表
foldRight	List(4,5,6).foldRight(0)(_ + _)	给定一个起始值和一个规约函数从右到左来规约列表
reduce	List(4,5,6).reduce(_ + _)	给定一个规约函数，从列表中的第一个元素开始规约列表
reduceLeft	List(4,5,6).reduceLeft(_ + _)	给定一个规约函数，从列表中的第一个元素从左到右开始规约列表
reduceRight	List(4,5,6).reduceRight(_ + _)	给定一个规约函数，从列表中的第一个元素从右到左开始规约列表
scan	List(4,5,6).scan(0)(_ + _)	取一个初始值和一个规约函数，返回各个累加值的一个列表
scanLeft	List(4,5,6).scanLeft(0)(_ + _)	取一个初始值和一个规约函数，从左到右返回各个累加值的一个列表
scanRight	List(4,5,6).scanRight(0)(_ + _)	取一个初始值和一个规约函数，从右到左返回各个累加值的一个列表