Scala——List中的高阶函数的使用：map，flatMap，filter，filterNot，groupBy，sorted，sortBy，# List使用排序函数sorted，，reduce

List使用map与flatMap函数

object LsitHightFun {
  def main(args: Array[String]): Unit = {
    //创建一个List，不可变的集合
    val list: List[Int] = (1 to 10).toList

    // def map[B](f: A => B): TraversableOnce[B]
    //map - >  f:(A) => B
    // A：集合List中数据类型
    val mapList: List[Int] =list.map(item=>{
      item*item
    })
    println(mapList.mkString("{",",","}"))
    println("================================")

    //分割单词
    val lineList = List(
      "hadoop hive spark hadoop java",
      "spark java sqool hive",
      "hadoop hive spark java"
    )

    //String -> Array(Iterable)
    val mapSplit: List[Array[String]] =
      lineList.map(item=>item.split(" "))
    var index =0
    val mapSize= mapSplit.size
    //遍历输出
    while( index < mapSize){
      println(mapSplit(index).mkString(","))
      index += 1
    }

    //压平函数
    var faltSplit: List[String] = lineList.flatMap(item=>item.split(" "))
    println(faltSplit)
  }
}

List使用过滤函数falter与falterNot

object LsitHightFun {
  def main(args: Array[String]): Unit = {
    //创建一个List，不可变的集合
    val list: List[Int] = (1 to 10).toList
   //过滤函数
    //filter为true留下,filterNot为true不要
    //变量使用一次可以用 _ 省略
    val filterList = list.filter(item => item %2 ==0)
    val filterList2 = list.filter(_ %2 ==0)
    println(filterList)
    val filterNotList = list.filterNot(item => item %2 ==0)
    val filterNotList2 = list.filterNot(_ %2 ==0)
    println(filterNotList)
        }
    }

List使用groupBy函数

object LsitHightFun {
  def main(args: Array[String]): Unit = {
    //分割单词
    val lineList = List(
      "hadoop hive spark hadoop java",
      "spark java sqool hive",
      "hadoop hive spark java"
    )
     //压平函数
    var faltSplit: List[String] = lineList.flatMap(item=>item.split(" "))
    println(faltSplit)
    //分组函数
    // def groupBy[K](f: A => K)
    //A:List中元素，K：分组类别
     val groupByHash = faltSplit.groupBy(line=> line.hashCode % 7)
    //Map(0 -> List(java, java, java),
    // 1 -> List(hive, hive, hive),
    // 2 -> List(sqool),
    // -6 -> List(hadoop, hadoop, hadoop),
    // 4 -> List(spark, spark, spark))
    println(groupByHash)
  }
}

List使用排序函数sorted，sortedBy，sortWith

object LsitHightFun {
  def main(args: Array[String]): Unit = {
 //排序
    /**
      * sorted
      *  默认情况下，依据集合中List的元素，自然排序规则：升序
      * sortBy
      *   指定元素的排序规则（升序，还是降序）
      */
    val list2 = List(11,8,12,88,33,55,77,24,46,34)
    var sortList1 = list2.sorted
    println(sortList1)
    val sortList2 = list2.sortBy(item => -item)
    println(sortList2)
    val sortList3 = list2.sortBy(-_)
    println(sortList3)
    val sortList4 =list2.sortWith((x1,x2)=> x1 >x2)//降序
    println(sortList4)
    val sortList5 =list2.sortWith((x1,x2)=> x1 < x2)//降序
    println(sortList5)
    val sortList6 =list2.sortWith((_ < _))//升序
    println(sortList6)
  }
}

List使用reduce聚合函数

object LsitHightFun {
  def main(args: Array[String]): Unit = {
    //创建一个List，不可变的集合
    val list: List[Int] = (1 to 10).toList
    //reduce  ->   op: (A1, A1) => A1
    //第一个参数A1: 可以理解为 聚合时  临时变量 ，初始值 集合head的值
    //第二个参数A2:每个元素的值
    //默认使用reduceLeft，即左面的变量为临时变量
    var reduceList: Int = list.reduce((x1, x2)=>{
      println(s"x1=$x1,x2=$x2")
      x1 + x2
    })
    println(reduceList)
    var reduceRigth: Int = list.reduceRight((x1, x2)=>{
      println(s"x1=$x1,x2=$x2")
      x1 + x2
    })
    println(reduceRigth)
  }
}