Scala学习（6）——集合之高阶函数

//可以使用Range，to，until创建list集合
    val list: List[Int] = Range(1,10).toList
    println(list.mkString("\t"))

    /**
      * final def map[B]( f: (A) ⇒ B): List[B]
      * map():f:(A) => B
      * 这里的函数map是list的一个方法，等价于MapReduce的map
      * 将集合中的每个元素取出 传递供给函数f进行调用，返回结果
      * 这里可以是map的数据清洗
      */

    //--------完整写法
    val mapList: List[Int] = list.map(value => {
      value * 2
    })
    //简写
    val mapList1: List[Int] = list.map(_ * 2)
    println(mapList1.mkString(","))

    //上面两行代码的简写
    println(list.map(_ * 2).mkString(","))

    //例如：分隔单词
    val lineList = List(
      "hadoop hive sqoop flume scala",
      "spark redis mongoDB azkaban",
      "zookeeper kafka nginx Hbase"
    )

    val linesWords: List[Array[String]] = lineList.map(line => line.split(" "))
    //遍历输出：List[Array[String]]，
    // 由于list里中还存着一个Array，因此需要嵌套循环遍历
    println("------------")
    linesWords.foreach(line => {
      line.foreach(word => print(word +"\t"))
      println()
    })

    /**
      * 压平，将多行内容按规则分割后放到一行
      * final def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): List[B]
      */
    val lineWords = lineList.flatMap(_.split(" "))
    lineWords.foreach(word => print(word + "\t"))

    println()

    /**
      * 过滤，数据过滤，可以自定义过滤规则
      * def filter(p: (A) ⇒ Boolean): TraversableOnce[A]
      * 返回true则保留，返回false则过滤
      */
    val filterList: List[Int] = list.filter((value) => if(value % 2 == 0) true else false)
    //上一行代码的简写
    val filterList1: List[Int] = list.filter(_ % 2 == 0)
    println(filterList.mkString(","))

    /**
      * 分组，可指定分组条件,
      * 返回的是map（key-value）
      * Map[Int, List[Int]],
      * key和value的类型scala可以推断，也可自己写
      * def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]
      */
    val groupMap: Map[Int, List[Int]] = list.groupBy(_ % 2)
    groupMap.foreach(println)

    /**
      * 排序
      * sorted
      *   默认情况下，依据集合list中的元素，自然排序规则 进行 升序排序
      * sortBy
      *   指定元素排序规则
      * sortWith
      *   主要针对集合中元素，如果 复杂的数据类型，指定排序规则
      */
    val list1 = List[Int](1,5,2,7,45,53,9,16)
    //sorted：默认排序方式是升序，如果是字符串，按字典顺序排序
    println(list1.sorted)

    //降序排列，item => - item
    println(list1.sortBy(-_).mkString(","))

    // def sortWith(lt: (A, A) => Boolean)
    // 类比java中的compareTo
    println(list1.sortWith(_>_).mkString(","))  //降序
    println(list1.sortWith(_<_).mkString(","))  //降序

    /**
      * def reduce( op: (A1, A1) => A1 ): A1 = reduceLeft(op)
      */
    //reduce是reduceLeft，第一次取list中的第一和第二个
    //之后x2循环往右取，x1作为 临时变量
    println("-----------reduce（reduceLeft）------------")
    list1.reduce((x1,x2) => {
      println(s"x1：$x1  x2：$x2")
      x1 + x2
    })

    //与reduceLeft相反，第一次取最后两个，
    // 之后x2作为 临时变量，x1循环往左取
    println("-----------reduceRight------------")
    list1.reduceRight((x1,x2) => {
      println(s"x1：$x1  x2：$x2")
      x1 + x2
    })