Scala Collection Method

• 接收一元函數

  • map 轉換元素，主要應用於不可變集合

    (1 to 10).map(i => i * i)
    (1 to 10).flatMap(i => (1 to i).map(j => i * j))

  • transform 與 map 相同，不過用於可變集合，直接轉換

    ArrayBuffer("Peter", "Paul", "Mary").transform(_.toUpperCase)

  • collect 接收偏函數(PartialFunction)做爲參數；模式匹配也是一種偏函數

    "-3+4".collect {
        case '+' => 1 ; 
        case '-' => -1 
    } // Vector(-1, 1)

  • groupBy 按指定函數分組，返回 Map

    val words = Array("Abc", "ab")
    val map = words.groupBy(_.substring(0, 1).toUpperCase)
    // Map(A -> Array(Abc, ab))

• 接收二元函數
  • reduceLeft 從左向右規約 f(f(f(a, b), c), d)

  List(1, 7, 2, 9).reduceLeft(_ - _)
    // ((1 - 7) - 2) - 9 = 1 - 7 - 2 - 9 = -17

  • reduceRight 從右向左規約 f(a, f(b, f(c, d)))

    List(1, 7, 2, 9).reduceRight(_ - _)
    // 1 - (7 - (2 - 9)) = 1 - 7 + 2 - 9 = -13

  • foldLeft 提供初始值+二元函數，從左向右摺疊，每次計算結果在左側
    • 可用 /:（表示樹形左側）操做符表示，(init /: collection)(function)
  • foldRight 提供初始值+二元函數，從右向左摺疊，每次計算結果在右側
    • 可用 :\（表示樹形右側）操做符表示，(collection :\ init)(function)

    List(1, 7, 2, 9).foldLeft(0)(_ - _)  
    (0 /: List(1, 7, 2, 9))(_ - _)
    // 0 - 1 - 7 - 2 - 9 = -19

  • scanLeft 和 scanRight 結合了 folding 和 mapping，結果爲全部的中間過程值

    (1 to 10).scanLeft(0)(_ + _) // Vector(0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)

• zip 拉鍊，即將兩個集合各個元素像拉鍊同樣交叉結合在一塊兒

  List(1,2,3) zip List("a","b","c") // List((1,a), (2,b), (3,c))

  • 長度不一致的集合則以較小的長度爲準

• zipAll 爲長度較短的集合設置默認值，

  this.zipAll(that, thisDefault, thatDefault)

• zipWithIndex 返回元素及對應的下標

  "Scala".zipWithIndex
  //  Vector((S,0), (c,1), (a,2), (l,3), (a,4))

• view 爲集合建立延遲視圖
  scala val lazyView = (1 to 1000000).view lazyView.take(100).last //100
  • 對視圖的操做都不會當即計算（包括第一個元素也不會）
  • 與 Stream 不一樣，不會緩存任何值
  • apply 方法會強制計算整個視圖，使用 lazyView.take(i).last 代替 lazyView(i)
• par 並行化集合，後續應用的方法都會併發計算
  scala for (i <- (0 until 100).par) print(s" $i") // 1-99
  • 很好的解決併發編程問題
  • 將集合變爲對於的並行化實現
  • 對於產生的結果，與串行方式的結果一致 （如 for...yield...）
  • 可以使用 seq，toArray 等方法將集合還原
  • 部分方法不能併發操做
    • 使用 reduce 替代 reduceLeft，先對各部分集合操做，而後聚合結果，但操做必須知足結合律
    • 使用 aggregate 替代 foldLeft，先對各部分集合操做，而後用另外一個操做將結果聚合
    str.par.aggregate(Set[Char]())(_ + _, _ ++ _) // 等價於 str.foldLeft(Set[Char]())(_ + _)