集合计算函数

（1）求和

  1.   val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
  3.     //（1）求和
  4.     println(list.sum)

（2）求乘积

  val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
    //（2）求乘积
    println(list.product)

（3）最大值

  val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
    //（3）最大值
    println(list.max)

（4）最小值

  val list: List[Int] = List(1, 5, -3, 4, 2, -7, 6)
    //（4）最小值
    println(list.min)

高级函数

过滤(filter)

遍历一个集合并从中获取满足指定条件的元素组成一个新的集合

  val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
  val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
  val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")

 //（1）过滤
  println(list.filter(x => x % 2 == 0))

案例:

遍历集合里面每一个元素,给运算完返回值为true的值留下,为false的值舍弃掉

val list1 = List(30, 5, 7, 60, 1, 20)
// 过滤出来奇数,偶数就不要了
val list2 = list1.filter(x => x % 2 == 1)
//简化版本,和上面的作用是一样的.
val list3 = list1.filter(_ % 2 == 1)
println(list2) // 输出:List(5, 7, 1)

转化/映射（map）

将集合中的每一个元素映射到某一个函数

Map就是一进一出,原来输入的元素个数是几个,那么出来的个数也是一样的.

案例

val list1 = List(30, 50, 70, 60, 10, 20)
//得到每个元素的平方
val list2: List[Int] = list1.map(x => x * x)
println(list2) //输出: List(900, 2500, 4900, 3600, 100, 400)
// 得到每个元素乘以2的值 ,下面两种是一样的结果,x => x可以简写为_
val list3: List[Int] = list1.map(x => x * 2)
val list4: List[Int] = list1.map(_ * 2)
println(list4) // 输出: List(60, 100, 140, 120, 20, 40)

Flatten

集合里面的元素必须也是集合,

    val list = List(List(1, 23), List(2, 3, 4), List(3, 4, 5))
    // 得到新的集合: List(1,23,2,3,4,3,4,5)
    val list2: List[Int] = list.flatten

    println(list2) // 输出: List(1, 23, 2, 3, 4, 3, 4, 5)

扁平化+映射(FlatMap)

flatMap其实就是Map加Flatten

集合中的每个元素的子元素映射到某个函数并返回新集合

注：flatMap相当于先进行map操作，在进行flatten操作

val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")
//（3）扁平化
println(nestedList.flatten)
//（4）扁平化+映射 注：flatMap相当于先进行map操作，在进行flatten操作
println(wordList.flatMap(x => x.split(" ")))

案例: 根据空格切割

val list = List("hello world", "hello hello", "atguigu aaa bbb")

val list3 = list.flatMap(x => x.split(" "))
// 简写
val list4 = list.flatMap(_.split(" "))
println(list3) // 输出: List(hello, world, hello, hello, atguigu, aaa, bbb)

Foreach

foreach: 只进不出,没有返回值.
替换掉for循环

   val list1 = List(30, 50, 70, 60, 10, 20)
    // 下面三行代码效果是一样的
    list1.foreach(x => println(x)) //打印里面每个元素
    list1.foreach(println) // 打印里面每个元素
    list1.foreach(println(_)) //打印里面每个元素

分组(group)

按照指定的规则对集合的元素进行分组

val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))
val wordList: List[String] = List("hello world", "hello atguigu", "hello scala")
//（5）分组
println(list.groupBy(x => x % 2))

案例

val list1 = List(30, 5, 7, 60, 1, 20)
//获取偶数和奇数值,同时判断一下,返回的HashMap的key就是这个返回判断的内容
val map = list1.groupBy(x => if (x % 2 == 0) "偶数" else "奇数")
println(map) // 输出:HashMap(偶数 -> List(30, 60, 20), 奇数 -> List(5, 7, 1))
//获取偶数和奇数值
val value = list1.groupBy(x => x % 2 == 1)
println(value) //输出: HashMap(false -> List(30, 60, 20), true -> List(5, 7, 1))
//
val value2 = list1.groupBy(x => x % 2)
println(value2) // 输出: HashMap(0 -> List(30, 60, 20), 1 -> List(5, 7, 1))

Reduce简化（归约）

Reduce简化（归约） ：通过指定的逻辑将集合中的数据进行聚合，从而减少数据，最终获取结果。

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

// 将数据两两结合，实现运算规则
val i: Int = list.reduce( (x,y) => x-y )
println("i = " + i)

// 从源码的角度，reduce底层调用的其实就是reduceLeft
//val i1 = list.reduceLeft((x,y) => x-y)

// ((4-3)-2-1) = -2
val i2 = list.reduceRight((x,y) => x-y)
println(i2)

案例2

// 聚合操作
val list1 = List(30, 50, 70, 60, 10, 20)
//下面四个效果是一样的.
val result: Int = list1.reduce((x, y) => x + y)
val result2: Int = list1.reduce(_ + _)
val result3: Int = list1.reduceRight(_ + _)
val result4: Int = list1.sum
println(result3) // 输出: 240

折叠Fold

Fold折叠：化简的一种特殊情况。

案例实操：fold基本使用

// fold方法使用了函数柯里化，存在两个参数列表
// 第一个参数列表为 ： 零值（初始值）
// 第二个参数列表为： 简化规则

val list1 = List(30, 50, 70, 60, 10, 20)
val r: Int = list1.foldLeft(0)(_ + _)
println(r) // 输出: 240
// 左折叠成字符串
val result = list1.foldLeft("")((x, y) => x + y)
println(result) //输出:  305070601020
// 右折叠
val result2 = list1.foldRight("a")((x, y) => x + y)
println(result2) //输出: 305070601020a
//左折叠另外一种写法,等价于foldLeft
val result4 = (0 /: list1) (_ + _)
//右折叠另外一种写法,等价于foldRight
val result5 = (list1 :\ 0) (_ + _)

案例实操：两个集合合并

// 两个Map的数据合并
val map1 = mutable.Map("a"->1, "b"->2, "c"->3)
val map2 = mutable.Map("a"->4, "b"->5, "d"->6)

val map3: mutable.Map[String, Int] = map2.foldLeft(map1) {
    (map, kv) => {
        val k = kv._1
        val v = kv._2

        map(k) = map.getOrElse(k, 0) + v

        map
    }
}

println(map3)

合并两个Map集合

 // 合并两个Map
    val map1 = Map("a" -> 1, "b" -> 2, "c" -> 3)
    val map2 = Map("a" -> 10, "c" -> 30, "d" -> 40)
    // Map(a -> 11, b -> 2, c -> 33, d -> 40)
    // 最终的结果是Map
    val map3 = map1.foldLeft(map2)((map, kv) => {

      val k = kv._1
      val v = kv._2
      map + (k -> (map.getOrElse(k, 0) + v))
    })
    println(map3) // 输出: Map(a -> 11, c -> 33, d -> 40, b -> 2)