11. Scala數據結構(下)-集合操做

11.1 集合元素的映射-map映射操做 

　　11.1.1 看一個實際需求

　　　　　　要求：請將List(3,5,8)中全部的元素都*2，將其結果放到一個新的集合中返回，即返回一個新的List(6,10,16)，請編寫程序實現

　　11.1.2 map映射操做 

　　　　   

　　11.1.3 使用傳統方法

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    /*
    請將List(3,5,8) 中的全部元素都 * 2 ，
    將其結果放到一個新的集合中返回，即返回一個新的List(6,10,16), 請編寫程序實現.

     */

    val list1 = List(3, 5, 8) //集合
    var list2 = List[Int]() //新的集合，準備放入新的內容
    for (item <- list1) { //遍歷
      list2 = list2 :+ item * 2 // 對元素*2 ，而後加入list2集合
    }
    println("list2=" + list2) //List(6,10,16)

  }
}

　　　　　　－上述案例演示的分析和小結

　　　　　　　　1) 優勢

　　　　　　　　　　處理方法比較直接，好理解

　　　　　　　　2) 缺點

　　　　　　　　　　不夠簡潔高效

　　　　　　　　　　沒有體現函數式編程特色 集合 => 函數 => 新的集合 => 函數 ...

　　　　　　　　　　不利於處理複雜的數據處理業務

　　11.1.4 高階函數基本使用案例1 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    //使用高階函數
    val res = test(sum2 _, 3.5)
    println("res=" + res)

    //在scala中，能夠把一個函數直接賦給一個變量,可是不執行函數
    val f1 = myPrint _
    f1() //執行


  }

  def myPrint(): Unit = {
    println("hello,world!")
  }

  //說明
  //1. test就是一個高階函數
  //2. f: Double => Double 表示一個函數， 該函數能夠接受一個Double,返回Double
  //3. n1: Double 普通參數
  //4. f(n1) 在test函數中，執行 你傳入的函數
  def test(f: Double => Double, n1: Double) = {
    f(n1)
  }

  //普通的函數, 能夠接受一個Double,返回Double
  def sum2(d: Double): Double = {
    println("sum2被調用")
    d + d
  }

}

　　11.1.5 高階函數應用案例2 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    test2(sayOK)

  }

  //說明test2是一個高階函數，能夠接受一個 沒有輸入，返回爲Unit的函數
  def test2(f: () => Unit) = {
    f()
  }

  def sayOK() = {
    println("sayOKKK...")
  }

  def sub(n1: Int): Unit = {

  }

}

　　11.1.6 使用map映射函數來解決  

//請將 List(3,5,8) 中的全部元素都 * 2 , 將其結果放到一個新的集合中返回,即返回一個新的 List(6,10,16), 請編寫程序實現.

  val list = List(3, 5, 8)
  //說明 list.map(multiple) 作了什麼
  //1. 將 list 這個集合的元素 依次遍歷
  //2. 將各個元素傳遞給 multiple 函數 => 新 Int
  //3. 將獲得新 Int ,放入到一個新的集合並返回
  //4. 所以 multiple 函數調用 3

  val list2 = list.map(multiple)
  println("list2=" + list2) //List(6,10,16)

  def multiple(n: Int): Int = {
    println("multiple 被調用~~")
    2 * n
  }

　　11.1.7 深入理解map映射函數的機制-模擬實現 

//深入理解 map 映射函數的機制-模擬實現
  class MyList {
    val list1 = List(3, 5, 8, 9) //新的集合
    var list2 = List[Int]()

    //寫 map
    def map(f: Int => Int): List[Int] = {
      //遍歷集合
      for (item <- this.list1) {
        //過濾,扁平化。。。
        list2 = list2 :+ f(item)
      }
      list2
    }
  }

  object MyList {
    def apply(): MyList = new MyList()
  }

　　11.1.9 flatmap映射: flat即壓扁，壓平，扁平化映射 

　　　　　　－扁平化說明

　　　　　　　　flatmap：flat即壓扁，壓平，扁平化，效果就是將集合中的每一個元素的子元素映射到某個函數並返回新的集合

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    val names = List("Alice", "Tom", "Nick")

    //需求是將List集合中的全部元素，進行扁平化操做，即把全部元素打散
    val names2 = names.flatMap(upper)
    println("names2=" + names2)

  }

  def upper(s: String): String = {
    s.toUpperCase
  }
}

11.2 集合元素的過濾-filter 

　　　　　　－基本說明 

　　　　　　　　filter：將符合要求的數據(篩選)放置到新的集合中

　　　　　　－案例演示

　　　　　　　　應用案例：將 val names = List("Alice","Tom","Nick") 集合中首字母爲'A'的篩選到新的集合

　　　　　　　　思考：若是這個使用傳統的方法，如何完成？

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    /*
    選出首字母爲A的元素
     */
    val names = List("Alice", "Tom", "Nick")
    val names2 = names.filter(startA)
    println("names=" + names)
    println("names2=" + names2)
  }

  def startA(str: String): Boolean = {
    str.startsWith("A")
  }
}

11.3 化簡  

　　11.3.1 看一個需求 

　　　　　　val list  = List(1,20,30,4,5)，求出list的和

　　11.3.2 化簡的介紹： 

　　　　　　化簡：將二元函數引用於集合中的函數

　　　　　　上面的問題固然可使用遍歷list方法來解決，這裏使用scala的簡化方式來完成

　　11.3.3 案例演示 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    /*
    使用化簡的方式來計算list集合的和
     */

    val list = List(1, 20, 30, 4, 5)
    val res = list.reduceLeft(sum) //接收一個函數時，也能夠直接傳入一個匿名函數

    //執行的流程分析
    //步驟 1 (1 + 20)
    //步驟 2 (1 + 20) + 30
    //步驟 3 ((1 + 20) + 30) + 4
    //步驟 4 (((1 + 20) + 30) + 4) + 5 = 60

    println("res=" + res) // 60

  }

  def sum(n1: Int, n2: Int): Int = {
    println("sum被調用~~")
    n1 + n2
  }
}

　　11.3.4 對reduceLeft的運行機制的說明 

　　　　　　1) def reduceLeft[B >: A](@deprecatedName('f) op: (B,A) => B): B

　　　　　　2) reduceLeft(f) 接收的函數須要的形式爲 op: (B,A) => B): B

　　　　　　3) reduceLeft(f) 的運行規則是 從左邊開始執行將獲得的結果返回給第一個參數

　　　　　　4) 而後繼續和下一個元素運行，將獲得的結果繼續返回給第一個參數，繼續...

　　　　　　　　即: //((((1+2)+3)+4)+5) = 15

11.4 摺疊 

　　11.4.1 基本介紹 

　　　　　　－fold函數將上一步返回的值做爲函數的第一參數繼續傳遞參與運算，直到list中的全部元素被遍歷

　　　　　　－能夠把reduceLeft看作簡化版的foldLeft

　　　　　　如何理解：　　

  def reduceLeft[B >: A](@deprecatedName('f) op: (B, A) => B): B =
    if (isEmpty) throw new UnsupportedOperationException("empty.reduceLeft")
    else tail.foldLeft[B](head)(op)
  //能夠看到. reduceLeft 就是調用的 foldLeft[B](head),而且是默認從集合的 head 元素開始操做的。
  

 　　　　　　－相關函數：fold，foldLeft，foldRight，能夠參考reduce的相關方法理解

　　11.4.2 應用案例  

　　　　　　看下面代碼看看輸出什麼，並分析緣由

　　　　　　案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4)

    def minus(num1: Int, num2: Int): Int = {
      num1 - num2
    }

    //說明
    //1. 摺疊的理解和化簡的運行機制幾乎同樣.
    //理解 list.foldLeft(5)(minus) 理解成 list(5,1, 2, 3, 4) list.reduceLeft(minus)

    //步驟  (5-1)
    //步驟  ((5-1) - 2)
    //步驟  (((5-1) - 2) - 3)
    //步驟  ((((5-1) - 2) - 3)) - 4 = - 5

    println(list.foldLeft(5)(minus)) // 函數的柯里化

    ////理解 list.foldRight(5)(minus) 理解成 list(1, 2, 3, 4, 5) list.reduceRight(minus)
    // 步驟 (4 - 5)
    // 步驟 (3- (4 - 5))
    // 步驟 (2 -(3- (4 - 5)))
    // 步驟 1- (2 -(3- (4 - 5))) = 3
    println(list.foldRight(5)(minus)) //

  }
}

　　11.4.3 foldLeft和foldRight縮寫方法分別是：/:和:\ 

　　　　　　－案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val list4 = List(1, 9)
    def minus(num1: Int, num2: Int): Int = {
      num1 - num2
    }
    var i6 = (1 /: list4) (minus) // =等價=> list4.foldLeft(1)(minus)
    println("i6=" + i6)

    i6 = (100 /: list4) (minus) //=等價=> list4.foldLeft(100)(minus)
    println(i6) // 輸出?

    i6 = (list4 :\ 10) (minus) // list4.foldRight(10)(minus)
    println(i6) // 輸出? 2


  }
}

11.5 掃描 

　　11.5.1 基本介紹  

　　　　　　掃描，即對某個集合的全部元素作fold操做，可是會把產生的全部中間結果放置於一個集合中保存

　　11.5.2 應用案例

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    //普通函數
    def minus( num1 : Int, num2 : Int ) : Int = {
      num1 - num2
    }

    //5 (1,2,3,4,5) =>(5, 4, 2, -1, -5, -10) //Vector(5, 4, 2, -1, -5, -10)
    val i8 = (1 to 5).scanLeft(5)(minus) //IndexedSeq[Int]
    println("i8=" + i8)

    //普通函數
    def add( num1 : Int, num2 : Int ) : Int = {
      num1 + num2
    }
    //(1,2,3,4,5) 5 => (20,19,17,14, 10,5)
    val i9 = (1 to 5).scanRight(5)(add) //IndexedSeq[Int]
    println("i9=" + i9)

  }
}

11.7 擴展-拉鍊(合併)  

　　11.7.1 基本介紹  

　　　　　　在開發中，當咱們須要將兩個集合進行 對偶元組合並，可使用拉鍊

　　11.7.2 應用案例 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    // 拉鍊
    val list1 = List(1, 2, 3)
    val list2 = List(4, 5, 6)
    val list3 = list1.zip(list2) // (1,4),(2,5),(3,6)
    println("list3=" + list3)

  }
}

　　11.7.3 拉鍊的使用注意事項 

　　　　　　1) 拉鍊的本質就是兩個集合的合併操做，合併後每一個元素是一個 對偶元組

　　　　　　2) 操做的規則以下圖

　　　　　　　　

　　　　　　3) 若是兩個集合個數不對應，會形成數據丟失

　　　　　　4) 集合不限於List，也能夠是其它集合，好比：Array

　　　　　　5) 若是要取出合併後的各個對偶元組的數據，能夠遍歷

    for(item<-list3) {
      print(item._1 + " " + item._2) //取出時,按照元組的方式取出便可
    }

11.8 擴展-迭代器 

　　11.8.1 基本說明 

　　　　　　　　經過iterator方法從集合得到一個迭代器，經過while循環和for表達式對集合進行遍歷(學習使用迭代器來遍歷)

　　11.8.2 應用案例 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    val iterator = List(1, 2, 3, 4, 5).iterator // 獲得迭代器
    /*
    這裏咱們看看iterator 的繼承關係
     def iterator: Iterator[A] = new AbstractIterator[A] {
    var these = self
    def hasNext: Boolean = !these.isEmpty
    def next(): A =
      if (hasNext) {
        val result = these.head; these = these.tail; result
      } else Iterator.empty.next()
     */
    println("--------遍歷方式1 while -----------------")
    while (iterator.hasNext) {
      println(iterator.next())
    }
    println("--------遍歷方式2 for -----------------")
    for (enum <- iterator) {
      println(enum) //
    }
  }

}

　　11.8.3 對案例演示的小結  

　　　　　　1) iterator的構建實際是AbstractIterator的一個匿名子類，該子類提供了

    def iterator: Iterator[A] = new AbstractIterator[A] {
      var these = self

      def hasNext: Boolean = !these.isEmpty

      def next(): A =
        if (hasNext) {
          val result = these.head;
          these = these.tail;
          result
        } else Iterator.empty.next()

    }

　　　　　　2) 該AbstractIterator子類提供了hasNext，next等方法

　　　　　　3) 所以，咱們可使用while的方式，使用hasNext，next方法變量

11.9 擴展-流Stream 

　　11.9.1 基本說明 

　　　　　　stream是一個集合。這個集合，能夠用於存放無窮多個元素，可是這無窮個元素並不會一次性生產出來，而是須要用到多大的區間，就會動態的生產，末尾元素遵循lazy規則(即：要使用結果才進行計算)

　　11.9.2 建立Stream對象  

　　　　　　－案例

  def numsForm(n: BigInt): Stream[BigInt] = n #:: numsForm(n + 1)

  val stream1 = numsForm(1)

　　　　　　－說明

　　　　　　　　1) Stream集合存放的數據類型是BigInt

　　　　　　　　2) numsForm是自定義的一個函數，函數名是程序員指定的

　　　　　　　　3) 建立的集合的第一個元素是n，後續元素生成的規則是n+1

　　　　　　　　4) 後續元素生成的規則是能夠程序員指定的

　　11.9.3 流的應用案例 

  //建立 Stream
  def numsForm(n: BigInt) : Stream[BigInt] = n #:: numsForm(n + 1)
  val stream1 = numsForm(1)
  println(stream1) //
  //取出第一個元素
  println("head=" + stream1.head) //
  println(stream1.tail) // 當對流執行 tail 操做時,就會生成一個新的數據.
  println(stream1) //

11.10 擴展-視圖View 

　　11.10.1 基本介紹 

　　　　　　Stream的懶加載特性，也能夠對其餘集合應用view方法來獲得相似的效果，具體有以下特色

　　　　　　　　1) view方法產出一個老是被懶執行的集合

　　　　　　　　2) view不會緩存數據，每次都要從新計算，好比遍歷View時

　　11.10.2 應用案例 

　　　　　　請找到1-100中，數字倒敘排列和它自己相同的全部數

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    def multiple(num: Int): Int = {
      num
    }

    //若是這個數，逆序後和原來數相等，就返回true,不然返回false
    def eq(i: Int): Boolean = {
      println("eq 被調用..")
      i.toString.equals(i.toString.reverse)
    }

    //說明: 沒有使用view,常規方式
    val viewSquares1 = (1 to 100).filter(eq)
    println(viewSquares1)


    //使用view，來完成這個問題,程序中，對集合進行map,filter,reduce,fold...
    //你並不但願當即執行，而是在使用到結果才執行，則可使用view來進行優化.
    val viewSquares2 = (1 to 100).view.filter(eq)
    println(viewSquares2)
    //遍歷
    for (item <- viewSquares2) {
      println("item=" + item)
    }
    
  }
}

11.11擴展-並行集合

　　11.11.1基本介紹 

　　　　　　1) Scala爲了充分使用多核CPU，提供了並行集合(有別於前面的串行集合)，用於多核環境的並行計算

　　　　　　2) 主要用到的算法有：

　　　　　　　　Divide and conquer: 分治算法，Scala經過splitters(分解器)，combiners(組合器)等抽象層來實現，主要原理是將計算工做分解不少任務，分發給一些處理器去完成，並將它們處理結果合併返回

　　　　　　　　Work stealin算法，主要用於任務調度負載均衡(load-balancing)，通俗點完成本身的全部任務以後，發現其餘人還有活沒幹完，主動(或被安排)幫他人一塊兒幹，這樣達到儘早幹完的目的

　　11.11.2 應用案例  

　　　　　　－parallel(並行)

　　　　　　　　打印1～5

    (1 to 5).foreach(println(_))
    println()
    (1 to 5).par.foreach(println(_))

 　　　　　　－查看並行集合中元素訪問的線程

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    val result1 = (0 to 100).map { case _ => Thread.currentThread.getName }.distinct
    val result2 = (0 to 100).par.map { case _ => Thread.currentThread.getName }.distinct
    println(result1) //非並行
    println("--------------------------------------------")
    println(result2) //並行
  }
}

11.12 擴展-操做符 

　　11.12.1 基本介紹  

　　　　　　這部份內容沒有必要刻意去記憶，語法使用的多了，天然就會熟練的使用，該部份內容瞭解就能夠

　　11.12.2 操做符擴展 

　　　　　　1) 若是想在變量名、類名等定義中使用語法關鍵字(保留字)，能夠配合反引號反引號，好比 val `val` = 23

　　　　　　2) 中置操做符：A操做符B 等同於 A.操做符(B)

　　　　　　3) 後置操做符：A操做符 等同於 A.操做符，若是操做符定義的時候不帶()則調用時不能加括號

　　　　　　4) 前置操做符：+、-、!、~等操做符A 等同於 A.unary_操做符

　　　　　　5) 賦值操做符：A操做符=B 等同於 A=A 操做符B，好比A +=B 等價 A = A + B

　　　　　　6) 案例演示

object boke_demo01 {

  def main(args: Array[String]): Unit = {

    val n1 = 1
    val n2 = 2
    val r1 = n1 + n2 // 3
    val r2 = n1.+(n2) // 3 看Int的源碼便可說明


    val monster = new Monster
    monster + 10
    monster.+(10)

    println("monster.money=" + monster.money) // 20

    println(monster ++)
    println(monster.++)
    println("monster.money=" + monster.money) // 22

    !monster
    println("monster.money=" + monster.money) // -22

  }
}

class Monster {
  var money: Int = 0

  //對操做符進行重載 (中置操做符)
  def +(n: Int): Unit = {
    this.money += n
  }

  //對操做符進行重載(後置操做符)
  def ++(): Unit = {
    this.money += 1
  }

  //對操做符進行重載(前置操做符，一元運算符)
  def unary_!(): Unit = {
    this.money = -this.money
  }
}