Scala10_集合03_集合高阶方法

1.reduce

1.Scala中对数据的操作一般都是两两计算

object Scala10_Collection_reduce {
  def main(args: Array[String]): Unit = {
    //TODO 集合 - 计算方法 - 聚合功能函数
    //Scala集合提供了一些用于聚合数据功能的函数
    //但是聚合逻辑不确定
    // 1->N flatMap
    // N->1 reduce (聚合)

    //todo 1.reduce 将集合中的元素两两聚合，聚合规则自己制定
    val list = List(1, 2, 3, 4)
    //参数是(A1,A1)=>A1
    //Scala中数据操作一般都是两两操作
    val i: Int = list.reduce((x, y) => x + y)
    println(i)//10
  }
}

2.reduceLeft&reduceRight

object Scala10_Collection_reduce {
  def main(args: Array[String]): Unit = {
    //TODO 集合 - 计算方法 - 聚合功能函数
    //Scala集合提供了一些用于聚合数据功能的函数
    //但是聚合逻辑不确定
    // 1->N flatMap
    // N->1 reduce (聚合)

    //todo 1.reduce 将集合中的元素两两聚合，聚合规则自己制定
    val list = List(1, 2, 3, 4, 5)
    //参数是(A1,A1)=>A1   两个操作数和返回值类型一致
    //Scala中数据操作一般都是两两操作
    val i: Int = list.reduce(_-_)//-1 -4 -9 -13
    println(i)//10

    //todo 2.reduceLeft
    //参数： （A，B）=>A   两个操作数类型可以不一致，返回值和第一个操作数一致
    val i1: Int = list.reduceLeft(_ - _) //-1 -4 -9 -13
    println(i1)

    //todo 3.reduceRight
    // 先反转，再reduceLeft  (5,4,3,2,1)
    val i2: Int = list.reduceRight(_ - _) //-1 4 -2 3
    println(i2)

    //todo 4.理解reduceLeft和reduceRight
    //reduceLeft从左加括号  ((((1, 2), 3), 4), 5)  再将逗号变为运算符  结果即：  -1 -4 -5 -10
    //reduceRight从右加括号 (1, (2, (3,( 4, 5))))                           -1 4 -2 3
  }
}

reduce方法总结

1. 三个方法底层都是reduceLeft
2. reduce : (A,A)=>A
3. reduceLeft: (B,A)=>B
4. reduceRight: 从右往左加括号

3.fold

reduce系列的方法是一个集合内部做聚合；
现在需要做集合之间的聚合；

object Scala11_Collection_fold {
  def main(args: Array[String]): Unit = {
    //todo fold 折叠  聚合多个集合
    //fold 函数柯里化，两个参数列表
    //第一个参数列表是 集合外的数据，是初始值
    //第二个参数列表表示数据两两计算的规则
    val list = List(1,2,3,4,5)
    val i: Int = list.fold(0)(_ - _) // 0,1,2,3,4,5
    println(i)//-15

    //fold(z:A)((A,A)=>A)
    //foldLeft(z:B)((B,A)=>B)
    //foldRight   reversed.foldLeft(z)((x,y)=> op(y,x))
    val i1: Int = list.foldRight(0)(_ - _)  //  1,2,3,4,5,0 然后就是reduceRight过程了
    println(i1)//3


    //todo Scan 保留每一步操作的结果到List中
    val ints: List[Int] = list.scanRight(5)(_ - _) //1,2,3,4,5,5
    println(ints) //List(-2, 3, -1, 4, 0, 5)

  }
}

4.List自定义排序

object Scala16_Collection_SortBy {
  def main(args: Array[String]): Unit = {
   val user1 = new User()
   user1.id = 1
    user1.age = 10

    val user2 = new User()
    user2.id = 2
    user2.age = 20

    val user3 = new User()
    user3.id = 2
    user3.age = 30

    val list = List(user1,user2,user3)

    //list.sortBy(_.id)

    //todo sortWith List的方法，自定义排序
    //两个两个排，排序方式符合预期返回true
    val users: List[User] = list.sortWith(
      (left, right) => {
        if (left.id < right.id) {
          true
        } else if (left.id > right.id) {
          false
        } else {
          left.age > right.age
        }
      }
    )

    println(users)
    //List(User[1][10], User[2][30], User[2][20])
  }


  class User{
    var id : Int = _
    var age : Int = _

    override def toString: String = {
      s"User[${id}][${age}]"
    }
    }
}

5.练习题

    val map1 = Map("a" -> 1, "b" -> 2)
    val map2 = Map("a" -> 3, "c" -> 4)
合并成 Map("a" -> 4, "b" -> 2,"c" -> 4)

分析
两个map做聚合，肯定用fold了
将一个map做初始值；另一个map做遍历聚合
初始值为map类型，map中元素为kv类型，肯定不一致，肯定用foldLeft了
每个元素和map的聚合逻辑就是 有则+v,无则+0

object Scala12_Collection_练习 {
  def main(args: Array[String]): Unit = {
    val map1 = Map("a" -> 1, "b" -> 2)
    val map2 = Map("a" -> 3, "c" -> 4)

    // Map("a" -> 4, "b" -> 2,"c" -> 4)
    val stringToInt: Map[String, Int] = map1.foldLeft(map2)(
      (map, t) => {
        map.updated(t._1, map.getOrElse(t._1, 0) + t._2)
      }
    )
    println(stringToInt)  //Map(a -> 4, c -> 4, b -> 2)

  }
}