Scala Immutable Collection

1：Scala Collections-list

List[T]----->泛型

创建列表：

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

列表添加元素 ::

scala> val b = 0 :: a
b: List[Int] = List(0, 1, 2, 3, 4)

scala> val c = "x" :: "y"::"z"::Nil
c: List[String] = List(x, y, z)

scala> "z":: Nil
res4: List[String] = List(z)

scala> "y":: res4
res5: List[String] = List(y, z)

scala> "x":: res5
res6: List[String] = List(x, y, z)

合并两个列表：

scala> val d =  a ::: c
d: List[Any] = List(1, 2, 3, 4, x, y, z)                // Any是Scala所有类的父类

访问元素：

scala> a.head
res7: Int = 1

scala> d.head
res8: Any = 1

scala> c.head
res9: String = x

tail得到的是除了列表第一个元素之外的所有元素组成的列表--------》尾列表

scala> a.tail
res10: List[Int] = List(2, 3, 4)

scala> c.tail
res11: List[String] = List(y, z)

判空：

scala> a.isEmpty
res12: Boolean = false

scala> c.isEmpty
res13: Boolean = false

scala> Nil.isEmpty
res14: Boolean = true

遍历列表：

scala> def walkthru(l:List[Int]):String = {
     | if(l.isEmpty) ""
     | else l.head.toString +" "+walkthru(l.tail)
     | }
walkthru: (l: List[Int])String

scala> walkthru(a)
res15: String = "1 2 3 4 "

2：Scala list的高级使用

filter：

scala> a.filter(x => x % 2==1)        //保留奇数
res16: List[Int] = List(1, 3)

scala> a.filter(_%2==1)
res23: List[Int] = List(1, 3)

filter参数为一个匿名函数，输入参数x代表的是列表里面的一个元素，filter遍历列表里面的元素

满足条件则保留元素

scala> "99 Red Balloons".toList
res17: List[Char] = List(9, 9,  , R, e, d,  , B, a, l, l, o, o, n, s)

scala> "99 Red Balloons".toList.filter(x => Character.isDigit(x))    //保留数字
res18: List[Char] = List(9, 9)

takeWhile：

scala> "99 Red Balloons".toList.takeWhile(x => x!='B')
res19: List[Char] = List(9, 9,  , R, e, d,  )

取元素，测试结果为true则取数，不满足则终止

3：Scala list-map(映射)

scala> c
res20: List[String] = List(x, y, z)

scala> c.map(x => x.toUpperCase)
res21: List[String] = List(X, Y, Z)

scala> c.map(_.toUpperCase)
res22: List[String] = List(X, Y, Z)

//选择出奇数，并且将得到的每个元素+10

scala> a.filter(_%2==1).map(_+10)
res24: List[Int] = List(11, 13)

//列表中存储的也是列表

scala> val q = List(a,List(4,5,6))
q: List[List[Int]] = List(List(1, 2, 3, 4), List(4, 5, 6))

scala> q.map(x => x.filter(_%2==0))
res26: List[List[Int]] = List(List(2, 4), List(4, 6))

scala> q.map(_.filter(_%2==0))
res27: List[List[Int]] = List(List(2, 4), List(4, 6))

//flatMap

scala> q.flatMap(_.filter(_%2==0))
res28: List[Int] = List(2, 4, 4, 6)

flatMap与map的区别

map返回的是原来集合的类型

flatMap对于两层的list会转换为一层

4:Scala reduceLeft与flodLeft（规约操作）

reduceLeft：

scala> a.reduceLeft((x,y) => x+y)
res29: Int = 10

scala> a
res30: List[Int] = List(1, 2, 3, 4)

scala> a.reduce(_ + _)
res31: Int = 10

flodLeft：（柯里化）

                         //初始值

scala> a.foldLeft(0)(_+_)
res32: Int = 10

scala> a.foldLeft(1)(_*_)
res33: Int = 24

5：Scala Range与Stream

Range：

scala> 1 to  10                  //左闭右闭
res34: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1 to 10 by 2
res35: scala.collection.immutable.Range = Range(1, 3, 5, 7, 9)

scala> (1 to 10).toList               //转列表
res36: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1 until 10            //左闭右开
res37: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

stream：（lazy list）惰性求值

scala> 1 #:: 2 #:: 3#:: Stream.empty
res0: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> val stream = (1 to 1000000000).toStream
stream: scala.collection.immutable.Stream[Int] = Stream(1, ?)

scala> stream.head
res1: Int = 1

scala> stream.tail
res2: scala.collection.immutable.Stream[Int] = Stream(2, ?)

6：Scala tuple与map

tuple：

scala> (1,2)
res3: (Int, Int) = (1,2)

scala> 1->2
res4: (Int, Int) = (1,2)

scala> (1,"Alice","Math",99.8)
res5: (Int, String, String, Double) = (1,Alice,Math,99.8)

访问tuple的成员：

scala> t._1
res6: Int = 1

scala> t._2
res7: String = Alice

scala> t._3
res8: String = Math

scala> t._4
res9: Double = 99.8

scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)

//求一个list的长度，各个元素的和，各个元素的平方和

//输入一个list，输出一个元组

scala> a
res10: List[Int] = List(1, 2, 3)

scala> def sumSq(in:List[Int]):(Int,Int,Int) =
     | in.foldLeft((0,0,0))((t,v)=>(t._1+1,t._2+v,t._3+v*v))
sumSq: (in: List[Int])(Int, Int, Int)

scala> sumSq(a)
res11: (Int, Int, Int) = (3,6,14)

Map[k,v]：

scala> val p = Map(1->"David",9->"Elwood")
p: scala.collection.immutable.Map[Int,String] = Map(1 -> David, 9 -> Elwood)

//取值

scala> p(1)
res12: String = David

scala> p(9)
res13: String = Elwood

//判断key是否在map中

scala> p.contains(1)
res14: Boolean = true

scala> p.contains(2)
res15: Boolean = false

scala> p.keys
res16: Iterable[Int] = Set(1, 9)

scala> p.values
res17: Iterable[String] = MapLike(David, Elwood)

//添加，新生成一个map

scala> p + (8->"Alex")
res18: scala.collection.immutable.Map[Int,String] = Map(1 -> David, 9 -> Elwood, 8 -> Alex)

//删除，新生成一个map

scala> p - 1
res19: scala.collection.immutable.Map[Int,String] = Map(9 -> Elwood)

//添加多个，封装在List中，新生成一个map

scala> p ++ List(2->"Alice",5->"Bob")
res21: scala.collection.immutable.Map[Int,String] = Map(1 -> David, 9 -> Elwood, 2 -> Alice, 5 -> Bob)

scala> p -- List(1,9,2)
res22: scala.collection.immutable.Map[Int,String] = Map()

scala> p
res23: scala.collection.immutable.Map[Int,String] = Map(1 -> David, 9 -> Elwood)

scala> p ++ List(2->"Alice",5->"Bob") -- List(9,1)
res24: scala.collection.immutable.Map[Int,String] = Map(2 -> Alice, 5 -> Bob)

7：快速排序

scala> :paste
// Entering paste mode (ctrl-D to finish)

def qSort(a:List[Int]) : List[Int] =
if(a.length<2) a
else
qSort(a.filter(_ < a.head)) ++
a.filter(_ == a.head)++
qSort(a.filter(_ > a.head))

// Exiting paste mode, now interpreting.

qSort: (a: List[Int])List[Int]

scala> qSort(List(3,1,2))
res25: List[Int] = List(1, 2, 3)

scala> qSort(List(9,3,2,1,4,7,8,5))
res26: List[Int] = List(1, 2, 3, 4, 5, 7, 8, 9)