大数据Spark“蘑菇云”行动-第14课Scala集合上的函数式编程实战及Spark源码鉴赏

集合一定是可以迭代的。
1、在Scala的集合体系中Iterable是共同的Trait，Iterable要求继承者实现一些共同的方法，例如对元素的遍历等；
2、Array是一个非常基础的数据结构，不从属于Scala集合的体系；

---

3、Range示例：
在Scala的集合体系中，集合分为可变集合与不可变集合之分；不可变的集合在scala.collection.immutable包中，可变的集合在scala.collection.mutable。

scala> 1 to 10
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> res0.foreach(println(_))
1
2
3
4
5
6
7
8
9
10

---

4、List示例：
List是元素的列表集合，是不可变的：
第一点： List中head是指第一个元素，tail是指剩下的元素构成的List集合；
第二点： 使用::这个操作符来把List和其它的元素进行组拼来构建新的List
第三点： 如果集合中没有元素的话，此时为Nil，例如说List中只有一个元素，那么head就是这个元素本身，tail操作就会返回Nil

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

scala> println(list.head)
1

scala> println(list.tail)
List(2, 3, 4, 5)

scala>  println(0::list)
List(0, 1, 2, 3, 4, 5)

---

5、LinkedList是元素可变的列表

scala> var linkedList = scala.collection.mutable.LinkedList(1,2,3,4,5)
linkedList: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4, 5)

scala> println(linkedList.elem)
1

scala> println(linkedList.tail)
LinkedList(2, 3, 4, 5)

scala> println(linkedList.head)
1

scala>    while(linkedList != Nil){
     |       println(linkedList.elem)
     |        linkedList = linkedList.tail
     |      }
1
2
3
4
5

scala> linkedList = scala.collection.mutable.LinkedList(1,2,3,4,5)
linkedList: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4, 5)

scala> linkedList.foreach(println(_))
1
2
3
4
5

scala> while(linkedList != Nil){
     | println(linkedList.elem)
     | linkedList=linkedList.next
     | }
1
2
3
4
5

scala> var linkedList = scala.collection.mutable.LinkedList(1,2,3,4,5)
linkedList: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4, 5)

scala> linkedList.++(scala.collection.mutable.LinkedList(11,22,33,44,55))
res17: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4, 5, 11, 22, 33, 44, 55)

scala> res17.foreach(println(_))
1
2
3
4
5
11
22
33
44
55

scala> linkedList.+:(9)
res20: scala.collection.mutable.LinkedList[Int] = LinkedList(9, 1, 2, 3, 4, 5)

scala> println(res20)
LinkedList(9, 1, 2, 3, 4, 5)

scala> res20.foreach(println(_))

---

6、Set示例
Set是元素不可重复的集合,且元素是无序的；
HashSet中的元素不可变且不可重复且不能够保证顺序；

scala>      val set = Set(1,2,3,4,5)
set: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

scala>      println(set)
Set(5, 1, 2, 3, 4)

//下面代码示例元素不可重复，加了一个元素值为1的元素，可以发现重复的元素加不进去
scala>val setMore = set + 1
setMore: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

scala>println(setMore)
Set(5, 1, 2, 3, 4)

//加了一个元素值为6的元素
scala>val setMore = set + 6
setMore: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

//加了3个元素:6、7、8
scala>      val setMore = set + (6,7,8)
setMore: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)

7、HashSet示例
元素不可变切不可重复，且不保持顺序。如果要保持顺序，那么就用LinkedHashSet

scala>  val hashSet = scala.collection.mutable.HashSet(1,2,3)
hashSet: scala.collection.mutable.HashSet[Int] = Set(1, 2, 3)

scala>  hashSet += 5
res27: hashSet.type = Set(1, 5, 2, 3)

scala>  hashSet += 50
res28: hashSet.type = Set(1, 5, 2, 50, 3)

scala>  println(hashSet)
Set(1, 5, 2, 50, 3)

scala> hashSet += (60,70,80)
res30: hashSet.type = Set(60, 1, 70, 5, 2, 50, 3, 80)

scala> hashSet.foreach(println(_))
60
1
70
5
2
50
3
80

8、LinkedHashSet示例
LinkedHashSet会维护元素的插入顺序；

首先，看一下HashSet，元素插入之后，没有维护插入的顺序 
scala> val hashSet = scala.collection.mutable.HashSet(1,2,3)
hashSet: scala.collection.mutable.HashSet[Int] = Set(1, 2, 3)

scala> hashSet += 5
res33: hashSet.type = Set(1, 5, 2, 3)

scala> hashSet += 6
res34: hashSet.type = Set(1, 5, 2, 6, 3)

//HashSet没有维护插入的顺序
scala> hashSet.foreach(println(_))
1
5
2
6
3

//接下来看一下LinkedHashSet，它能维护插入的顺序
scala> val hashSet = scala.collection.mutable.LinkedHashSet(1,2,3)
hashSet: scala.collection.mutable.LinkedHashSet[Int] = Set(1, 2, 3)

scala>  hashSet += 5
res36: hashSet.type = Set(1, 2, 3, 5)

scala> hashSet += 6
res37: hashSet.type = Set(1, 2, 3, 5, 6)

//打印里面的元素值，可以看见LinkedHashSet维护元素的插入顺序
scala> hashSet.foreach(println(_))
1
2
3
5
6

9、SortedSet示例
SortedSet会自动的把插入的元素进行排序；

scala> val sortedSet = scala.collection.mutable.SortedSet(1, 2, 3, 5, 50, 4)
sortedSet: scala.collection.mutable.SortedSet[Int] = TreeSet(1, 2, 3, 4, 5, 50)

scala> sortedSet.foreach(println(_))
1
2
3
4
5
50

---

10、集合的函数式编程

本文的核心高潮来了，看代码：

List[String]("I am into Spark so much","Scala is powerful").flatMap { x => x.split(" ") }
res48: List[String] = List(I, am, into, Spark, so, much, Scala, is, powerful)

List[String]("I am into Spark so much","Scala is powerful").map { x => x.split(" ") }
res51: List[Array[String]] = List(Array(I, am, into, Spark, so, much), Array(Scala, is, powerful))

10.1 先理解一下以上两行代码，flatMap和map的区别：
map函数会对每一条输入进行指定的操作，然后为每一条输入返回一个对象；而flatMap函数则是整个操作的集合,把结果合并成一个输出，也就是“先映射后扁平化”。

10.2 接下来把上面List中的每一个元素，计数为1，代码如下：

List[String]("I am into Spark so much","Scala is powerful").flatMap { x => x.split(" ") }.map { x => (x, 1) }
res63: List[(String, Int)] = List((I,1), (am,1), (into,1), (Spark,1), (so,1), (much,1), (Scala,1), (is,1), (powerful,1))

10.3 上一步List的每个元素：是Tupple类型，存入的是单词，单词出现的个数，接下来取出每个单词的个数。代码如下：

List[String]("I am into Spark so much","Scala is powerful").flatMap { x => x.split(" ") }.map((_,1)).map(_._2)
res67: List[Int] = List(1, 1, 1, 1, 1, 1, 1, 1, 1)

10.4 统计全部单词的个数。代码如下：

List[String]("I am into Spark so much","Scala is powerful").flatMap { x => x.split(" ") }.map((_,1)).map(_._2).reduce(_+_)
res68: Int = 9

解释：下划线占位符非常强大。如果不用占位符也可以写成下面这种形式：

List[String]("I am into Spark so much","Scala is powerful").flatMap { x => x.split(" ") }.map {(_, 1) }.map(_._2).reduce((x,y) =>x + y)

下面再看一下占位符的示例：

//原始写法
    List(0,1,2,3,4,5).foreach { x => println(x) }
//下面使用占位符进行简化
    List(0,1,2,3,4,5).foreach {println(_) }
//只有一个参数的话，括号可以去掉
    List(0,1,2,3,4,5).foreach {println _ }

//继续简化，省略下划线
    List(0,1,2,3,4,5).foreach {println }
//也可以这写    
    List(0,1,2,3,4,5).foreach (println)

---

本博声明：
博文内容源自DT大数据梦工厂大数据Spark“蘑菇云”前置课程。相关课程内容视频可以参考：
百度网盘链接：http://pan.baidu.com/s/1cFqjQu（如果链接失效或需要后续的更多资源，请联系QQ460507491或者微信号：DT1219477246 获取上述资料，或者直接拨打 18610086859咨询）