scala 系列之 07scala 集合常用方法和函数操作

8 集合常用方法和函数操作

foreach

oreach 方法的原型：

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

该方法接受一个函数 f 作为参数， 函数 f 的类型为Elem => U，即 f 接受一个参数，参数的类型为容器元素的类型Elem，f 返回结果类型为 U。foreach 遍历集合的每个元素，并将f 应用到每个元素上。

**

sorted、sortBy

sorted：按照元素自身进行排序；

sortBy: 按照应用函数 f 之后产生的元素进行排序；

// 按照自身元素排序
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操作是针对集合的典型变换操作，它将某个函数应用到集合中的每个元素，并产生一个结果集合；

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的执行过程： 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)
// 筛选偶数组成新集合
list.filter(x => x % 2 == 0)
list.filter(_ % 2 == 0)

如何过滤出大于2的奇数？

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}"))

reduce、reduceLeft、reduceRight

reduce：reduce(op: (A1, A1) => A1): A1 。reduce操作是按照从左到右的顺序进行规约。(((1+2)+3)+4)+5

reduceLeft：reduceLeft[B >: A](f: (B, A) => B): B。是按照从左到右的顺序进行规约。 (((1+2)+3)+4)+5

reduceRight：reduceRight[B >: A](op: (A, B) => B): B。是按照从右到左的顺序进行规约。1+(2+(3+(4+5)))

单线程下： reduce 和 reduceLeft一样

并行集合运行下： reduce利用CPU数运行， 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:${b}")
      a + b
    })
    println(sum)
    println("------reduceLeft------------")
    val sum1: Int = list.reduceLeft((a: Int, b: Int) => {
      println(s"a:${a}, b:${b}")
      a + b
    })
    println(sum1)
    println("------reduceRight------------")
    val sum2: Int = list.reduceRight((a: Int, b: Int) => {
      println(s"a:${a}, b:${b}")
      a + b
    })
    println(sum2)
    println("-------并行集合的reduce-----------")
    // 利用并行集合多线程运算，没有顺序
    val sum3: Int = list.par.reduce((a: Int, b: Int) => {
      println(s"a:${a}, b:${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:${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:${b},threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum5)

**

**

如何简写？

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} + ${b} = ${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实现求最大值
scala> list.reduce((a:Int,b:Int) => {println(s"${a} vs ${b}");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:${b}")
      a+b
    })
    println(sum)
    println("------foldLeft------------")
    val sum1: Int = list.foldLeft(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:${b}")
      a + b
    })
    println(sum1)
    println("------foldRight------------")
    val sum2: Int = list.foldRight(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:${b}")
      a + b
    })
    println(sum2)
    println("-------并行集合的fold-----------")
    // 利用并行集合多线程运算，没有顺序
    val sum3: Int = list.par.fold(10)((a: Int, b: Int) => {
      println(s"a:${a}, b:${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:${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:${b},threadName:${Thread.currentThread().getName}")
      a + b
    })
    println(sum5)
  }
}

如何简写？

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

​ 将每个分区里面的元素进行聚合，然后用combine函数将每个分区的结果和初始值进行combine操作；

    val list = List(1,2,3,4,5)
    // 当集合不是并行集合时，combop函数不执行
    val sum: Int = list.aggregate(0)((a: Int, b: Int) => {
      println(s"step1:a:${a}, b:${b}")
      a + b
    },
      (a: Int, b: Int) => {
        println(s"step2:a:${a}, b:${b}")
        a + b
      }
    )
    println(sum)
//-------运行结果-----------------------------
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函数执行
    // step1:做基础聚合， step2:在step1 基础上做聚合，相当于combiner
    val sum2: Int = list.par.aggregate(0)((a: Int, b: Int) => {
      println(s"step1:a:${a}, b:${b}")
      a + b
    },
      (a: Int, b: Int) => {
        println(s"step2:a:${a}, b:${b}")
        a + b
      }
    )
    println(sum2)
//-------运行结果-----------------------------
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

总结：

reduce/reduceLeft/reduceRight: 认为每个元素类型一样

fold: 带有初始值的reduce，初始值类型和元素类型一样；并行集合下注意初始值的设定；

foldLeft/foldRight： 初始值类型和元素类型可以不一样，规约结果和初始值类型一致；并行集合下是单线程运算

aggregate：初始值类型和元素类型可以不一样，规约结果和初始值类型一致；并行集合下是利用CPU核数运算

groupBy、grouped

groupBy：将list 按照某个元素内的字段分组，返回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里的按照元素内的第一个进行分组
    val map: Map[String, List[(String, Int)]] = list.groupBy(_._1)
    println(map)
// -----输出结果-----------------------------
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)
    // 调用迭代器toBuffer，会把迭代器里的数据都迭代出来，有且只能迭代一次
    println(it.toBuffer)
    println(it)

// -----输出结果-----------------------------
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)
// 按照单词统计数值
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)
//-------运行结果-----------------------------
List(1)
List(4)
List(1, 2, 3, 2, 3, 4)
List(2, 3, 4, 1, 2, 3)
List(2, 3)

实现 wordcount

实现统计 List("a b c d","a d e s") 单词的个数

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))