48_Scala 自带集合算子(filter、map、flatten、flatMap、group、reudce、fold)

1. filter 过滤算子

  object filterTest extends App {
    /*
    *  filter
    *     作用 : 传输过滤集合元素的函数,返回一个符合条件元素的新数组（会改变集合元素个数,但不会改变元素类型）
    *
    *     定义 : def filter(p: A => Boolean): List[A]
    *
    *     注意 : 1. 要搞清楚集合元素类型,示例 map (String,Int)
    *
    *
    * */
    var list = List(1, 3, -1, 5, 10)
    var map = Map[String, Int]("x" -> 10, "y" -> 9, "z" -> 8)

    //1. 过滤>0的元素
    val newList: List[Int] = list.filter(_ > 0)
    println(newList)
    //List(1, 3, 5, 10)

    //2. 过滤 key!=x 的元素
    private val newMap: Map[String, Int] = map.filter(_._1 != "x")
    println(newMap)
    //Map(y -> 9, z -> 8)

    //3. 关于匿名函数
    //  1.什么是匿名函数
    //      函数定义作为 参数传入
    //  2.匿名函数格式
    //      (参数名称:参数类型) => {方法体}
    //  3.简化的原则
    //      1. 参数类型可以省略
    //            (参数名称) => {方法体}
    //      2. 参数类型省略后, 如果只有一个参数,()可以省略
    //             参数名称 => {方法体}
    //      3. 当方法体只有一行时 {}可以省略
    //             参数名称 => 方法体
    //      4. 当方法体内 只使用一次参数时,可以省略 () => ,方法体内用 _来代替
    //             _ > 1

    //匿名函数 示例
    //需求 : 过滤 key!=x 的元素
    def f1(tp: (String, Int)): Boolean = {
      tp._1 != "x"
    }


    private val newMap1: Map[String, Int] = map.filter(f1) //非匿名函数
    private val newMap2: Map[String, Int] = map.filter(
      //匿名函数
      (tp: (String, Int)) => {
        tp._1 != "x"
      }
    )
    private val newMap3: Map[String, Int] = map.filter(
      //匿名函数(简化1-去掉数据类型)
      (tp) => {
        tp._1 != "x"
      }
    )
    private val newMap4: Map[String, Int] = map.filter(
      //匿名函数(简化2-去掉数据类型+去掉())
      tp => {
        tp._1 != "x"
      }
    )
    private val newMap5: Map[String, Int] = map.filter(
      //匿名函数(简化3-去掉数据类型+去掉()+去掉{})
      tp =>
        tp._1 != "x"
    )
    private val newMap6: Map[String, Int] = map.filter(
      //匿名函数(简化4-去掉数据类型+去掉()+去掉{}+去掉 参数名=>)
      _._1 != "x"
    )
    println(newMap1)
    println(newMap2)
    println(newMap3)
    println(newMap4)
    println(newMap5)
    println(newMap6)


  }

2. map 转换算子

  object mapTest extends App {
    /*
    *  map
    *     作用 : 传入转换集合元素的函数,返回一个转换后的新集合 (不会改变集合元素个数,但可能会改变元素类型)
    *
    *     定义 : def map[K2, V2](f: ((K, V)) => (K2, V2)): CC[K2, V2]
    *           def map[B](f: A => B): CC[B]
    *
    * */
    var list = List(1, 3, -1, 5, 10)
    var map = Map[String, Int]("x" -> 10, "y" -> 9, "z" -> 8)
    //1. 对list中的每个元素去绝对值
    private val newList: List[Int] = list.map(_.abs)
    println(newList)
    //List(1, 3, 1, 5, 10)

    //2. 将map中的key 转换为3次, 将x转为xxx
    private val newMap: Map[String, Int] = map.map(
      (tp: (String, Int)) => (tp._1 * 3, tp._2)
    )
    println(newMap)
    //Map(xxx -> 10, yyy -> 9, zzz -> 8)

    //3. 获取map的key的list
    private val keyList: immutable.Iterable[String] = map.map(
      (tp: (String, Int)) => tp._1
    )
    println(keyList)
    //List(x, y, z)

  }

 3. flatten 拉平算子

  object flattenTest extends App {
    /*
    *  map
    *     作用 : 将 集合元素类型是集合的集合,打散成原子粒度,并返回原子粒度的新集合
    *
    *     定义 : override def flatten[B](implicit toIterableOnce: A => IterableOnce[B]): CC[B]
    *
    *     注意 : 1. 只会 做一级拉平
    *           2. 元素类型必须是 集合类时,才能使用flatten
    *
    * */
    var list: List[List[Any]] = List(List(4, 5, 6), List(1, 2, List(8, 19)))
    //1. 将list拉平
    private val newList: List[Any] = list.flatten
    println(newList)
    // List(4, 5, 6, 1, 2, List(8, 19))

  }

 4. flatmap 扁平化+映射 (打散) 算子

  object flatmapTest extends App {
    /*
    *  flatmap
    *     作用 : 1.先将元素进行转换,转换成一个迭代器 2.在遍历迭代器 返回新的集合
    *
    *     定义 : final override def flatMap[B](f: A => IterableOnce[B]): List[B]
    *
    *     思考 : 先映射 再 拉平 ？
    *           1.先将元素进行转换,转换成一个迭代器
    *           2.在遍历迭代器
    * */
    var list: List[List[Any]] = List(List(4, 5, 6), List(1, 2, List(8, 19)))

    var arr: List[String] = List("Hello Java", "Hello Scala", "Hello Sql")

    //1.将 list拉平
    private val newList: List[Any] = list.flatMap(_.toIterable)
    println(newList)
    //List(4, 5, 6, 1, 2, List(8, 19))

    //2.将 字符串按照" "切分,并将其打散
    private val newArr: List[String] = arr.flatMap(_.split(" "))
    println(newArr)
    //List(Hello, Java, Hello, Scala, Hello, Sql)

  }

5. groupBy 分组算子

  object groupbyTest extends App {
    /*
    *  groupby
    *
    *     作用 : 根据传入的函数 将集合内元素分组
    *            函数的返回值 作为key,符合规则的元素作为value值
    *
    *     定义 : def groupBy[K](f: A => K): immutable.Map[K, C]
    *
    *     注意 :
    *
    * */
    var list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    var map = Map[String, Int]("x" -> 10, "y" -> 9, "z" -> 8, "x1" -> -10, "y1" -> -9, "z1" -> -8)

    //1. 对list元素 按照奇偶数分组,奇数为1,偶数为0
    private val newList: Map[Any, List[Int]] = list.groupBy(e => if (e % 2 == 0) 1 else 0)
    println(newList)
    //HashMap(0 -> List(1, 3, 5, 7, 9), 1 -> List(2, 4, 6, 8, 10))

    //2. 根据map的value分组,>0的为1,<0的位0
    private val newMap: Map[Any, Map[String, Int]] = map.groupBy(e => if (e._2 > 0) "大于0" else "小于0")
    println(newMap)
    //HashMap(小于0 -> HashMap(z1 -> -8, y1 -> -9, x1 -> -10), 大于0 -> HashMap(x -> 10, y -> 9, z -> 8))

  }