Scala学习笔记三Scala不可变集合

**

摘要：

**
去年开发的过程中使用过Kafka，了解到Kafka是用Scala编写的，今年在开发过程中，使用了spark，spark也是使用Scala编写的，并且在项目中使用了Scala开发，只是对Scala缺乏一个系统的学习，所以花了一个多月的时间看完了《快学Scala》，看完之后本来想写点摘要笔记，过程当中顺带看了慕课网Scala程序设计—基础篇，发现慕课网的基础讲解挺不错的，所以就把慕课网的讲解结合了个人的理解记录下来，慕课网的基础篇确实讲解的是基础，建议大家抽空看一下《快学Scala》，书本把原理的东西，以及Scala的很多概念讲解得更加详细

traversable:遍历
iterable:集合是可以迭代访问的
set:无序集合
seq:有意义的顺序集合
Map:映射，跟Java差不多

**

List[T]

**
T表示泛型，Scala会进行类型推导，有时候没必要指定T
操作：
val a=List(1,2,3,4)
> a:List[Int] = List (1,2,3,4) //创建List
val b= 0 :: a
> b: List[Int] =List (0,1,2,3,4) //添加元素
val c = “x” :: “y” ::“z” :: Nil
> c : List[String] = List (x,y,z) //创建list,Nil是指空的列表
val d= a : : : c
> d : List [Any] =List(1,2,3,4,x,y,z) //:::为连接两个list操作符
a.head
> res0:Int=1 //head方法返回list中第一个元素
a.tail
>res1:List[Int] = List(2,3,4) //tail方法返回list里面除了第一个意外的list集合（伪列表）
a.isEmpty
> res2:Boolean = false //这个方法返回list是否为空
Nil.isEmpty
>res3 : Boolean = true //空list返回为true
list的遍历方法
def walkthru(l:List[Int]) :String = {
if (l.isEmpty) “”
eles l.head.toString + “”+walkthru(l.tail)
}

**

List高级使用：

**
a.filter(x=>x%2==1)
> res4: List[Int] = List(1,3) //filter过滤，返回符合条件的集合，这里是返回奇数集合
//filter里面就是个匿名函数

“99 Red Balloons”.toList
>res5:List[Char] = List(9,9,R,e,d,B,a,l,l,o,o,n,s) //toList返回list集合
“99 Red Balloons”.toList.filter(x=>Character.isDigit(x))
> res6:List[Char] = List(9,9) //过滤出是数字的集合

“99 Red Balloons”.toList.takeWhile(x => x!=‘B’)
> res12:List[Char] = List (9,9,R,e,d,)//当不是B时就一直取值，遇到B停止取值

c.map(x=>x.toUpperCase)
> res6:List[String] = List(X,Y,Z) //map函数将List里面的每个元素进行操作
Scala中_下划线用于统配
以上map的写法可以简写成以下
c.map(toUpperCase) 结果是相同的
同样的以上的filter可以写成
a.filter(%2 == 1) //过滤出奇数

结合操作
a.filter(%2==1).map(+10)先过滤奇数，然后每个元素加10

val q=List(a,List(4,5,6))
> q:List[List[Int]] = List(List(1,2,3),List(4,5,6)) // List里面元素还是List的List集合
q.map(x = > x.filter(%2 == 0))
> res7:List[List[Int]] = List (List(2),List(4,6)) //对list进行map映射，映射后的每个元素还是
List，此时再对List里面的元素进行过滤，得到元素是偶数的集合
也可以写成 q.map(.filter(_%2==0))

q.flatMap(.filter(%2==0))
>res0:List[Int] = List (2,4,6)//直接将各个元素放在一个List集合里面

**

map跟flatMap区别

**
map返回跟父List相同的类型，flatMap只返回一层，打平了两层

**

归约操作

**

**

reduceLeft

** 集合元素从左边开始一次操作到右边
比如List（1，2，3.。。。n）就是1先和2然后取结果和3.。。一直到和n操作

foldLeft(z:U)(op:(U,T)=>U)
(z:U)z代表初始值,U是它的类型，op是个匿名函数，U是代表初始值，T是传进来的数据类型，
foldLeft跟reduceLeft操作步骤是相同的，但是foldLeft更加丰富，因为foldLeft操作可以有个初始值z，拿初始值跟后面的进行计算，然后返回的类型是初始值的类型U，而reduceLeft只能返回集合元素的类型

Range是一个整数序列，其中by是步长，就是中间隔了几个

stream是一个惰性求值的List，就是定义时，第一个参数是有值的，后面都是？，没值，只有用到的时候才会对它进行求值。

**

元祖

**类似于数据库中的一条记录

定义元祖，元素只有两个，称为对
可以用于一个函数的返回值
sumSeq方法返回一个元祖，分别是计算多少个元素，元素累加，元素相乘

**

Map（k,v

**）跟Java的map很相似
val p = Map(1->“David”,9->“Elwood”)
> scala.collection.immutable.Map[Int,String] = Map(1->david,9->Elwood)
p(10)
> res51: String = David
p.containd(1)
>res:Boolean = true
p.keys
> res:Iterable[Int] = Set(1,9)
p.values
> res:Iterable[String] = MapLike(David,Elwood)
p + (8->“Archer”) //新增元素
> res:scala.collection.immutable.Map[Int,String]=Map(1->david,9->Elwood,8->Archer)
p -1 //减掉对应的key值
在这里需要注意，计算的结果是返回一个新的Map，对原 4000 本初始的Map不进行操作，因为Map使用的是不可变集合
增加多个key,value.使用++操作符
p ++ List(2->“Alice”,5->“Bob”)
减去多个使用–
p – List(1,9,2)

快速排序，将一个list里面的元素一分为二，左边的数值比右边的小

小提示：在Scala中编辑大块代码使用：parse 操作符
scala集合阅读推荐：http://docs.scala-lang.org/overviews/collections/introduction.html