九、scala函數式編程-集合操做

1、集合操做1

一、Scala的集合體繫結構

// Scala中的集合體系主要包括：Iterable、Seq、Set、Map。其中Iterable是全部集合trait的根trai。這個結構與Java的集合體系很是類似。

// Scala中的集合是分紅可變和不可變兩類集合的，其中可變集合就是說，集合的元素能夠動態修改，而不可變集合的元素在初始化以後，就沒法修改了。分別對應scala.collection.mutable和scala.collection.immutable兩個包。

// Seq下包含了Range、ArrayBuffer、List等子trait。其中Range就表明了一個序列，一般可使用「1 to 10」這種語法來產生一個Range。 ArrayBuffer就相似於Java中的ArrayList。

二、List

// List表明一個不可變的列表
// List的建立，val list = List(1, 2, 3, 4)
// List有head和tail，head表明List的第一個元素，tail表明第一個元素以後的全部元素，list.head，list.tail
// List有特殊的::操做符，能夠用於將head和tail合併成一個List，0 :: list
// ::這種操做符要清楚，在spark源碼中都是有體現的，必定要可以看懂！
// 若是一個List只有一個元素，那麼它的head就是這個元素，它的tail是Nil

// 案例：用遞歸函數來給List中每一個元素都加上指定前綴，並打印加上前綴的元素


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


#
scala> list.head
res0: Int = 1

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

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

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

scala> list2
res4: List[Int] = List(0, 1, 2, 3, 4)

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

def decorator(list: List[Int], prefix: String) {
  if (list != Nil) {
    println(prefix + list.head)
    decorator(list.tail, prefix)
  }
}

// Exiting paste mode, now interpreting.

decorator: (list: List[Int], prefix: String)Unit

scala> decorator(List(1,2,3,4,5), "+")
+1
+2
+3
+4
+5

三、LinkedList

// LinkedList表明一個可變的列表，使用elem能夠引用其頭部，使用next能夠引用其尾部
scala> val li = scala.collection.mutable.LinkedList(1,2,3,4,5)
warning: there was one deprecation warning; re-run with -deprecation for details
li: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4, 5)

scala> li.elem
res6: Int = 1

scala> li.next
res7: scala.collection.mutable.LinkedList[Int] = LinkedList(2, 3, 4, 5)


// 案例：使用while循環將LinkedList中的每一個元素都乘以2
scala> :paste
// Entering paste mode (ctrl-D to finish)

val list = scala.collection.mutable.LinkedList(1,2,3,4,5)
var currentList = list
while (currentList != Nil) {
  currentList.elem = currentList.elem * 2
  currentList = currentList.next
}

// Exiting paste mode, now interpreting.

warning: there was one deprecation warning; re-run with -deprecation for details
list: scala.collection.mutable.LinkedList[Int] = LinkedList(2, 4, 6, 8, 10)
currentList: scala.collection.mutable.LinkedList[Int] = LinkedList()

// 案例：使用while循環將LinkedList中，從第一個元素開始，每隔一個元素，乘以2

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

val list = scala.collection.mutable.LinkedList(1,2,3,4,5,6,7,8,9,10)
var currentList = list
var first = true
while (currentList != Nil && currentList.next != Nil) {
   if (first) {currentList.elem = currentList.elem * 2; first = false }
   currentList = currentList.next.next
   if (currentList != Nil) currentList.elem = currentList.elem * 2
}

// Exiting paste mode, now interpreting.

warning: there was one deprecation warning; re-run with -deprecation for details
list: scala.collection.mutable.LinkedList[Int] = LinkedList(2, 2, 6, 4, 10, 6, 14, 8, 18, 10)
currentList: scala.collection.mutable.LinkedList[Int] = LinkedList()
first: Boolean = false

2、集合操做2

一、Set

// Set表明一個沒有重複元素的集合，Set爲trait，分爲可變與不可變兩種trait
// 將重複元素加入Set是沒有用的，好比val s = Set(1, 2, 3); s + 1; s + 4
scala> val s = Set(1,2,3)
s: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> s + 1
res1: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

scala> s + 4
res2: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)



// 並且Set是不保證插入順序的，也就是說，Set中的元素是亂序的，
scala> val s = new scala.collection.mutable.HashSet[Int]()
s: scala.collection.mutable.HashSet[Int] = Set()

scala> s += 1
res4: s.type = Set(1)

scala> s += 2
res5: s.type = Set(1, 2)

scala> s += 5
res6: s.type = Set(1, 5, 2)



// LinkedHashSet會用一個鏈表維護插入順序
scala> val s = new scala.collection.mutable.LinkedHashSet[Int]()
s: scala.collection.mutable.LinkedHashSet[Int] = Set()

scala> s += 1
res7: s.type = Set(1)

scala> s += 2
res8: s.type = Set(1, 2)

scala> s += 5
res9: s.type = Set(1, 2, 5)



// SrotedSet會自動根據key來進行排序
scala> val s = scala.collection.mutable.SortedSet("orange", "apple", "banana")
s: scala.collection.mutable.SortedSet[String] = TreeSet(apple, banana, orange)

二、集合的函數式編程

// 集合的函數式編程很是很是很是之重要！
// 必須徹底掌握和理解Scala的高階函數是什麼意思，Scala的集合類的map、flatMap、reduce、reduceLeft、foreach等這些函數，就是高階函數，由於能夠接收其餘函數
做爲參數；

// 高階函數的使用，也是Scala與Java最大的一點不一樣！！！由於Java裏面是沒有函數式編程的，也確定沒有高階函數，也確定沒法直接將函數傳入一個方法，
或者讓一個方法返回一個函數
// 對Scala高階函數的理解、掌握和使用，能夠大大加強你的技術，並且也是Scala最有誘惑力、最有優點的一個功能！


// 此外，在Spark源碼中，有大量的函數式編程，以及基於集合的高階函數的使用！ 因此必須掌握，才能看懂spark源碼
；



// map案例實戰：爲List中每一個元素都添加一個前綴
scala> val s1 = List("leo", "jen", "jack")
s1: List[String] = List(leo, jen, jack)

scala> val s2 = s1.map("name is " + _)
s2: List[String] = List(name is leo, name is jen, name is jack)



// faltMap案例實戰：將List中的多行句子拆分紅單詞
scala> val list = List("Hello World", "Hello Me", "Hello You")
list: List[String] = List(Hello World, Hello Me, Hello You)

scala> list.flatMap(_.split(" "))
res10: List[String] = List(Hello, World, Hello, Me, Hello, You)



// foreach案例實戰：打印List中的每一個單詞
scala> List("I", "have", "a", "beautiful", "house").foreach(println(_))
I
have
a
beautiful
house



// zip案例實戰：對學生姓名和學生成績進行關聯
scala> val nameList = List("leo", "jen", "jack")
nameList: List[String] = List(leo, jen, jack)

scala> val scoreList = List(100,90,80)
scoreList: List[Int] = List(100, 90, 80)

scala> nameList.zip(scoreList)
res14: List[(String, Int)] = List((leo,100), (jen,90), (jack,80))

三、案例：統計多個文本單詞計數

// 使用scala的io包將文本文件內的數據讀取出來
scala> val lines1 = scala.io.Source.fromFile("//home//scala//test01.txt").mkString
lines1: String =
"hello word
linux scala
centos ubuntu
"

scala> val lines2 = scala.io.Source.fromFile("//home//scala//test02.txt").mkString
lines2: String =
"mysql oracle
apache nginx
lvs keepalived
"

// 使用List的伴生對象，將多個文件內的內容建立爲一個List
scala> val line = List(lines1, lines2)
line: List[String] =
List("hello word
linux scala
centos ubuntu
", "mysql oracle
apache nginx
lvs keepalived
")

// 下面這一行纔是咱們的案例的核心和重點，由於有多個高階函數的鏈式調用，以及大量下劃線的使用，若是沒有透徹掌握以前的課講解的Scala函數式編程，那麼
下面這一行代碼，徹底可能會看不懂！！！

// 可是下面這行代碼其實就是Scala編程的精髓所在，就是函數式編程，也是Scala相較於Java等編程語言最大的功能優點所在

// 並且，spark的源碼中大量使用了這種複雜的鏈式調用的函數式編程

// 並且，spark自己提供的開發人員使用的編程api的風格，徹底沿用了Scala的函數式編程，好比Spark自身的api中就提供了map、flatMap、reduce、foreach，以及更
高級的reduceByKey、groupByKey等高階函數

// 若是要使用Scala進行spark工程的開發，那麼就必須掌握這種複雜的高階函數的鏈式調用！！！
scala> line.flatMap(_.split(" ")).map((_, 1)).map(_._2).reduceLeft(_ +  _)
res16: Int = 9