8 集合常用方法和函數(shù)操作

foreach

oreach 方法的原型：

// f 返回的類型是Unit， foreach 返回的類型是Unit
def foreach[U](f: Elem => U)

該方法接受一個函數(shù) f 作為參數(shù)肥卡， 函數(shù) f 的類型為Elem => U，即 f 接受一個參數(shù)事镣，參數(shù)的類型為容器元素的類型Elem步鉴，f 返回結(jié)果類型為 U。foreach 遍歷集合的每個元素璃哟，并將f 應(yīng)用到每個元素上氛琢。

file

**

sorted、sortBy

sorted：按照元素自身進行排序随闪；

sortBy: 按照應(yīng)用函數(shù) f 之后產(chǎn)生的元素進行排序阳似；

// 按照自身元素排序
val list0 = List(1,4,2,3,5)
list0.sorted
// 按照指定元素排序
val list1 = List(("a",3), ("c",1), ("b",2))
// 按照元組里第一個元素排序
list1.sortBy(_._1)
// 按照元組里第二個元素排序
list1.sortBy(_._2)    
// 按照元組里第二個元素降序排序    
list1.sortBy(_._2).reverse

flatten

當有一個集合的集合，然后你想對這些集合的所有元素進行操作時铐伴，就會用到 flatten撮奏；

List(List(1,2), List(3,4)) -----> List(1,2,3,4)

List(Array(1,2),Array(3,4)) -----> List(1,2,3,4)

List(Map("a"->1,"b"->2), Map("c"->3,"d"->4)) -----> List((a,1), (b,2), (c,3), (d,4))

val list = List(List(1,2), List(3,4))
list.flatten

注意：flatten 不支持元組

// 下面的方法報錯
val list = List((1,2), (3,4))
list.flatten

map, flatMap

map 操作

map操作是針對集合的典型變換操作，它將某個函數(shù)應(yīng)用到集合中的每個元素当宴，并產(chǎn)生一個結(jié)果集合畜吊；

map方法返回一個與原集合類型大小都相同的新集合，只不過元素的類型可能不同即供。

val list = List(1,2,3,4)
// 對list 里面的每個元素加1定拟，并返回新的集合
list.map(x => x+1)   // 等效于 list.map(_ + 1)
 
val list2 = List("a b c", "d e f")
// 新集合和原集合的類型不同
list2.map(x => x.split(" "))

flatMap 操作

flatMap的執(zhí)行過程： map --> flatten

val list = List("a b c", "d e f")
list.map(_.split(" ")).flatten
// flatMap =  map + flatten
list.flatMap(_.split(" "))

注意：同flatten一樣，不支持元組

filter

遍歷一個集合并從中獲取滿足指定條件的元素組成一個新的集合逗嫡；

val list = List(1,2,3,4,5)
// 篩選偶數(shù)組成新集合
list.filter(x => x % 2 == 0)
list.filter(_ % 2 == 0)

如何過濾出大于2的奇數(shù)？

val list = List(1,2,3,4,5)
list.filter(_ > 2).filter(_ % 2 != 0)
list.filter(f => if(f > 2 && f % 2 != 0) true else false)

并行集合

通過list.par 會將集合變成并行集合株依，可以利用多線程來進行運算驱证。

    val list = List(1,2,3,4,5)
    println("-----list-----------------")
    val s1 = list.foreach(f => println(s"${Thread.currentThread().getName} ==> ${f}"))
    println("-----list.par-------------")
    val s2 = list.par.foreach(f => println(s"${Thread.currentThread().getName} ==> ${f}"))

file

reduce、reduceLeft恋腕、reduceRight

reduce：reduce(op: (A1, A1) => A1): A1 抹锄。reduce操作是按照從左到右的順序進行規(guī)約。(((1+2)+3)+4)+5

reduceLeft：reduceLeft[B >: A](f: (B, A) => B): B。是按照從左到右的順序進行規(guī)約伙单。 (((1+2)+3)+4)+5

reduceRight：reduceRight[B >: A](op: (A, B) => B): B获高。是按照從右到左的順序進行規(guī)約。1+(2+(3+(4+5)))

單線程下： reduce 和 reduceLeft一樣

并行集合運行下： reduce利用CPU數(shù)運行吻育， reduceLeft 有方向念秧，只能單線程運行

    val list = List(1,2,3,4,5)
    println("-----reduce-------------")
    val sum: Int = list.reduce((a: Int, b: Int) => {
      println(s"a:${a}, b:$")
      a + b
    })
    println(sum)
    println("------reduceLeft------------")
    val sum1: Int = list.reduceLeft((a: Int, b: Int) => {
      println(s"a:${a}, b:$布疼")
      a + b
    })
    println(sum1)
    println("------reduceRight------------")
    val sum2: Int = list.reduceRight((a: Int, b: Int) => {
      println(s"a:${a}, b:$摊趾")
      a + b
    })
    println(sum2)
    println("-------并行集合的reduce-----------")
    // 利用并行集合多線程運算，沒有順序
    val sum3: Int = list.par.reduce((a: Int, b: Int) => {
      println(s"a:${a}, b:$游两,threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum3)
    println("-------并行集合的reduceLeft-----------")
    // reduceLeft 將并行集合多線程的運算變成了單線程砾层，有順序
    val sum4: Int = list.par.reduceLeft((a: Int, b: Int) => {
      println(s"a:${a}, b:$,threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum4)
    println("-------并行集合的reduceRight-----------")
    // reduceRight 將并行集合多線程的運算變成了單線程贱案，有順序
    val sum5: Int = list.par.reduceRight((a: Int, b: Int) => {
      println(s"a:${a}, b:$肛炮,threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum5)

file

**

file

**

如何簡寫？

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)
scala> list.reduce((a:Int,b:Int) => {a + b})
res18: Int = 15
scala> list.reduce((a:Int,b:Int) => {println(s"${a} + $宝踪 = ${a + b}");a + b})
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
res19: Int = 15
scala> list.sum
res20: Int = 15
// 求最大值
scala> list.max
res21: Int = 5
// 用reduce實現(xiàn)求最大值
scala> list.reduce((a:Int,b:Int) => {println(s"${a} vs $侨糟");if(a > b) a else b})
1 vs 2
2 vs 3
3 vs 4
4 vs 5
res22: Int = 5
scala> list.reduce((a:Int,b:Int) => {a + b})
res23: Int = 15
scala> list.reduce(_ + _)
res24: Int = 15
scala> list.par.reduce(_ + _)
res25: Int = 15

fold, foldLeft, foldRight

fold：fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 。帶有初始值的reduce肴沫，從一個初始值開始粟害，從左向右將兩個元素合并成一個，最終把列表合并成單一元素颤芬。((((10+1)+2)+3)+4)+5

foldLeft：foldLeft[B](z: B)(f: (B, A) => B): B 悲幅。帶有初始值的reduceLeft。((((10+1)+2)+3)+4)+5

foldRight：foldRight[B](z: B)(op: (A, B) => B): B 站蝠。帶有初始值的reduceRight汰具。1+(2+(3+(4+(5+10))))

object FoldDemo {
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4,5)
    println("-----fold-------------")
    val sum = list.fold(10)((a:Int, b:Int)=> {
      println(s"a:${a}, b:$")
      a+b
    })
    println(sum)
    println("------foldLeft------------")
    val sum1: Int = list.foldLeft(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:$菱魔")
      a + b
    })
    println(sum1)
    println("------foldRight------------")
    val sum2: Int = list.foldRight(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:$留荔")
      a + b
    })
    println(sum2)
    println("-------并行集合的fold-----------")
    // 利用并行集合多線程運算，沒有順序
    val sum3: Int = list.par.fold(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:$澜倦,threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum3)
    println("-------并行集合的foldLeft-----------")
    // foldLeft 將并行集合多線程的運算變成了單線程聚蝶，有順序
    val sum4: Int = list.par.foldLeft(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:$,threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum4)
    println("-------并行集合的foldRight-----------")
    // foldRight 將并行集合多線程的運算變成了單線程藻治，有順序
    val sum5: Int = list.par.foldRight(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:$碘勉,threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum5)
  }
}

file

如何簡寫？

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)
scala> list.fold(10)((a,b)=> a + b)
res35: Int = 25
    
scala> list.fold(10)(_ + _)
res36: Int = 25

aggregate

將每個分區(qū)里面的元素進行聚合桩卵，然后用combine函數(shù)將每個分區(qū)的結(jié)果和初始值進行combine操作验靡；

file

    val list = List(1,2,3,4,5)
    // 當集合不是并行集合時倍宾，combop函數(shù)不執(zhí)行
    val sum: Int = list.aggregate(0)((a: Int, b: Int) => {
      println(s"step1:a:${a}, b:$")
      a + b
    },
      (a: Int, b: Int) => {
        println(s"step2:a:${a}, b:$胜嗓")
        a + b
      }
    )
    println(sum)
//-------運行結(jié)果-----------------------------
step1:a:0, b:1
step1:a:1, b:2
step1:a:3, b:3
step1:a:6, b:4
step1:a:10, b:5
15
    
//--------------------------------------------------------------
    val list = List(1,2,3,4,5)
    // 當集合是并行集合時高职，combop函數(shù)執(zhí)行
    // step1:做基礎(chǔ)聚合， step2:在step1 基礎(chǔ)上做聚合辞州，相當于combiner
    val sum2: Int = list.par.aggregate(0)((a: Int, b: Int) => {
      println(s"step1:a:${a}, b:$怔锌")
      a + b
    },
      (a: Int, b: Int) => {
        println(s"step2:a:${a}, b:$")
        a + b
      }
    )
    println(sum2)
//-------運行結(jié)果-----------------------------
15
step1:a:0, b:1
step1:a:0, b:4
step1:a:0, b:5
step1:a:0, b:2
step1:a:0, b:3
step2:a:1, b:2
step2:a:4, b:5
step2:a:3, b:9
step2:a:3, b:12
15

總結(jié)：

reduce/reduceLeft/reduceRight: 認為每個元素類型一樣

fold: 帶有初始值的reduce孙技，初始值類型和元素類型一樣产禾；并行集合下注意初始值的設(shè)定；

foldLeft/foldRight： 初始值類型和元素類型可以不一樣牵啦，規(guī)約結(jié)果和初始值類型一致亚情；并行集合下是單線程運算

aggregate：初始值類型和元素類型可以不一樣，規(guī)約結(jié)果和初始值類型一致哈雏；并行集合下是利用CPU核數(shù)運算

groupBy楞件、grouped

groupBy：將list 按照某個元素內(nèi)的字段分組，返回map裳瘪。 List((k,v),(k,v)) --> Map(k, List(k,v))

grouped：按列表按照固定的大小進行分組土浸，返回迭代器。List(1,2,3,4,5) --> Iterator[List[A]]

    val list = List(("a",1),("a",2), ("b",3))
    // 將list里的按照元素內(nèi)的第一個進行分組
    val map: Map[String, List[(String, Int)]] = list.groupBy(_._1)
    println(map)
// -----輸出結(jié)果-----------------------------
Map(b -> List((b,3)), a -> List((a,1), (a,2)))     
        
        
    val list1 = List("a", 1, "a", 2, "b", 3, 4)
    val it: Iterator[List[Any]] = list1.grouped(2)
    println(it)
    // 調(diào)用迭代器toBuffer彭羹，會把迭代器里的數(shù)據(jù)都迭代出來黄伊，有且只能迭代一次
    println(it.toBuffer)
    println(it)
        
// -----輸出結(jié)果-----------------------------
non-empty iterator
ArrayBuffer(List(a, 1), List(a, 2), List(b, 3), List(4))
empty iterator

mapValues

對map映射里每個key的value 進行操作。

    val map = Map("b" -> List(1,2,3), "a" -> List(4,5,6))
    // 對每個key的value 求和
    val n1 = map.mapValues(_.sum)
    println(n1)

group by 和 mapValues 組合

scala> val list = List(("a",1), ("a", 1), ("b",1))
list: List[(String, Int)] = List((a,1), (a,1), (b,1))
// 按照單詞把元素分到一組派殷，但不運算    
scala> list.groupBy(f => f._1)
res49: scala.collection.immutable.Map[String,List[(String, Int)]] = Map(b -> List((b,1)), a -> List((a,1), (a,1)))
// 利用 mapValues 對每個key的value做運算
scala> res49.mapValues(f => f.size)
res51: scala.collection.immutable.Map[String,Int] = Map(b -> 1, a -> 2)
// 按照單詞統(tǒng)計數(shù)值
scala> val list = List(("a",1), ("a", 2), ("b",1), ("b", 3))
list: List[(String, Int)] = List((a,1), (a,2), (b,1), (b,3))
scala> list.groupBy(_._1)
res52: scala.collection.immutable.Map[String,List[(String, Int)]] = Map(b -> List((b,1), (b,3)), a -> List((a,1), (a,2)))
scala> res52.mapValues(_.map(_._2))
res54: scala.collection.immutable.Map[String,List[Int]] = Map(b -> List(1, 3), a -> List(1, 2))
scala> res52.mapValues(_.map(_._2).sum)
res55: scala.collection.immutable.Map[String,Int] = Map(b -> 4, a -> 3)

diff, union, intersect

diff : 兩個集合的差集还最；

union : 兩個集合的并集；

intersect: 兩個集合的交集毡惜；

    val nums1 = List(1,2,3)
    val nums2 = List(2,3,4)
    val diff1 = nums1 diff nums2
    println(diff1)
    val diff2 = nums2.diff(nums1)
    println(diff2)
    val union1 = nums1 union nums2
    println(union1)
    val union2 = nums2 ++ nums1
    println(union2)
    val intersection = nums1 intersect nums2
    println(intersection)
//-------運行結(jié)果-----------------------------
List(1)
List(4)
List(1, 2, 3, 2, 3, 4)
List(2, 3, 4, 1, 2, 3)
List(2, 3)

實現(xiàn) wordcount

實現(xiàn)統(tǒng)計 List("a b c d","a d e s") 單詞的個數(shù)

scala> val list = List("a b c d","a d e s")
list: List[String] = List(a b c d, a d e s)
scala> list.flatMap(_.split(" "))
res56: List[String] = List(a, b, c, d, a, d, e, s)
scala> res56.map(f => (f, 1))
res57: List[(String, Int)] = List((a,1), (b,1), (c,1), (d,1), (a,1), (d,1), (e,1), (s,1))
scala> res57.groupBy(_._1)
res58: scala.collection.immutable.Map[String,List[(String, Int)]] = Map(e -> List((e,1)), s -> List((s,1)), a -> List((a,1), (a,1)), b -> List((b,1)), c -> List((c,1)), d -> List((d,1), (d,1)))
scala> res58.mapValues(_.size)
res59: scala.collection.immutable.Map[String,Int] = Map(e -> 1, s -> 1, a -> 2, b -> 1, c -> 1, d -> 2)
scala> res59.toList
res60: List[(String, Int)] = List((e,1), (s,1), (a,2), (b,1), (c,1), (d,2))
scala> res60.sortBy(_._2)
res61: List[(String, Int)] = List((e,1), (s,1), (b,1), (c,1), (a,2), (d,2))
scala> res61.reverse
res62: List[(String, Int)] = List((d,2), (a,2), (c,1), (b,1), (s,1), (e,1))
scala>
scala> list.flatMap(_.split(" ")).map((_,1)).groupBy(_._1).mapValues(_.size)
res63: scala.collection.immutable.Map[String,Int] = Map(e -> 1, s -> 1, a -> 2, b -> 1, c -> 1, d -> 2)
scala> res63.toList.sortBy(_._2).reverse
res64: List[(String, Int)] = List((d,2), (a,2), (c,1), (b,1), (s,1), (e,1))

海汼部落原創(chuàng)文章拓轻，原文鏈接：http://hainiubl.com/topics/75742