scala函数式编程-常用的函数

1. foreach

   用来遍历集合的采用 foreach 来遍历集合, 可以让代码看起来更简洁, 更优雅.
   格式

   def foreach(f:(A) => Unit): Unit
   //简写形式
   def foreach(函数)
   

   说明

   

   案例

    def main(args: Array[String]): Unit = {
   
       val list: immutable.Seq[Range.Inclusive] = List(1 to 10)
       val list2: immutable.Seq[Int] = List(1, 2)
       list.foreach(
         println(_)
       )
       val array = Array(1 to 10)
       array.foreach(
         println(_)
       )
       val map: Map[Any, Any] = Map(1 -> "a", "2" -> 1)
       map.foreach((x) => println(x._1 + ":" + x._2))
       //结果
       //Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
       // Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
       // 1 :a
       // 2:1
     }
   
   

   注意

   当函数参数，只在函数体中出现一次，而且函数体没有嵌套调用时，可以使用下划线来简化函数定义

2. map 映射(map)

   用来对集合进行转换，集合的映射操作是指 将一种数据类型转换为另外一种数据类型的过程

   语法定义

   def map[B](f: (A) ⇒ B): TraversableOnce[B]
   

   说明

   

   案例

   // 案例: 演示map函数(映射)
   object ClassDemo25 {
    def main(args: Array[String]): Unit = {
     //1. 创建一个列表，包含元素1,2,3,4
     val list1 = List(1, 2, 3, 4)
     //2. 将上述的数字转换成对应个数的`*`, 即: 1变为*, 2变为**, 以此类推.
     //方式一: 普通写法
     val list2 = list1.map((x:Int) => "*" * x)
     println(s"list2: ${list2}")
     //方式二: 通过类型推断实现.
     val list3 = list1.map(x => "*" * x)
     println(s"list3: ${list3}")
     //方式三: 通过下划线实现.
     val list4 = list1.map("*" * _)
     println(s"list4: ${list4}")
   }
   }
   

3. flatmap 用来对集合进行映射扁平化操作

   扁平化映射可以理解为先map，然后再flatten，可以将嵌套的list集合进行扁平化

   def flatMap[B](f:(A) => GenTraversableOnce[B]): TraversableOnce[B]
   //简写形式:
   def flatMap(f:(A) => 要将元素A转换成的集合B的列表)
   

   说明

   

   案例

    def main(args: Array[String]): Unit = {
     //1. 有一个包含了若干个文本行的列表："hadoop hive spark flink flume", "kudu hbase sqoop
   storm"
     val list1 = List("hadoop hive spark flink flume", "kudu hbase sqoop storm")
     //2. 获取到文本行中的每一个单词，并将每一个单词都放到列表中.
     //方式一: 通过map, flatten实现.
     val list2 = list1.map(_.split(" "))
     val list3 = list2.flatten
     println(s"list3: ${list3}")
     //方式二: 通过flatMap实现.
     val list4 = list1.flatMap(_.split(" "))
     println(s"list4: ${list4}")
   }
   

4. filter

   用来过滤出指定的元素

   格式

   def filter(f:(A) => Boolean): TraversableOnce[A]
   //简写形式:
   def filter(f:(A) => 筛选条件)
   

   说明

   

   案例

    def main(args: Array[String]): Unit = {
     //1. 有一个数字列表，元素为：1,2,3,4,5,6,7,8,9
     val list1 = (1 to 9).toList
     //2. 请过滤出所有的偶数
     val list2 = list1.filter(_ % 2 == 0)
     println(s"list2: ${list2}")
   }
   

5. 排序

   分类

   

   默认排序(sorted)

   所谓的默认排序指的是 对列表元素按照升序进行排列 . 如果需要降序排列, 则升序后, 再通过 reverse 实现

   案例

   def main(args: Array[String]): Unit = {
     //1. 定义一个列表，包含以下元素: 3, 1, 2, 9, 7
     val list1 = List(3, 1, 2, 9, 7)
     //2. 对列表进行升序排序
     val list2 = list1.sorted
     println(s"list2: ${list2}")
     //3. 对列表进行降序排列.
     val list3 = list2.reverse
     println(s"list3: ${list3}")
   }
   

   指定字段排序(sortBy)

   语法

   def sortBy[B](f:(A) => B): List[A]
   //简写形式:
   def sortBy(函数对象)
   

   说明

   

   案例

    def main(args: Array[String]): Unit = {
     //1. 有一个列表，分别包含几下文本行："01 hadoop", "02 flume", "03 hive", "04 spark"
     val list1 = List("01 hadoop", "02 flume", "03 hive", "04 spark")
     //2. 请按照单词字母进行排序
     //val list2 = list1.sortBy(x => x.split(" ")(1))
     //简写形式:
     val list2 = list1.sortBy(_.split(" ")(1))
     println(s"list2: ${list2}")
   }
   

   自定义排序(sortWith)
   所谓的自定义排序指的是 根据一个自定义的函数 (规则)来进行排序

   语法

   def sortWith(f: (A, A) => Boolean): List[A]
   //简写形式:
   def sortWith(函数对象: 表示自定义的比较规则)
   

   说明

   

   案例

   def main(args: Array[String]): Unit = {
     //1. 有一个列表，包含以下元素：2,3,1,6,4,5
     val list1 = List(2,3,1,6,4,5)
     //2. 使用sortWith对列表进行降序排序
     //val list2 = list1.sortWith((x, y)=> x > y)  //降序
     //简写形式:
     val list2 = list1.sortWith(_ > _)   //降序
     println(s"list2: ${list2}")
   }
   

6. groupBy

   用来对集合元素按照指定条件分组

   语法

   def groupBy[K](f:(A) => K): Map[K, List[A]]
   //简写形式:
   def groupBy(f:(A) => 具体的分组代码)
   

   说明

   

   案例

    def main(args: Array[String]): Unit = {
     //1. 有一个列表，包含了学生的姓名和性别: "刘德华" -> "男", "刘亦菲" -> "女", "胡歌" -> "男"
     val list1 = List("刘德华" -> "男", "刘亦菲" -> "女", "胡歌" -> "男")
     //2. 请按照性别进行分组.
     //val list2 = list1.groupBy(x => x._2)
     //简写形式
     val list2 = list1.groupBy(_._2)
     //println(s"list2: ${list2}")
     //3. 统计不同性别的学生人数.
     val list3 = list2.map(x => x._1 -> x._2.size)
     println(s"list3: ${list3}")
   }
   

   聚合操作

7. reduce

   用来对集合元素进行聚合计算

   语法

   def reduce[A1 >: A](op:(A1, A1) ⇒ A1): A1
   //简写形式:
   def reduce(op:(A1, A1) ⇒ A1)
   

   说明

   

   案例

    def main(args: Array[String]): Unit = {
     //1. 定义一个列表，包含以下元素：1,2,3,4,5,6,7,8,9,10
     val list1 = (1 to 10).toList
     //2. 使用reduce计算所有元素的和
     //val list2 = list1.reduce((x, y) => x + y)
     //简写形式:
     val list2 = list1.reduce(_ + _)
     val list3 = list1.reduceLeft(_ + _)
     val list4 = list1.reduceRight(_ + _)
     println(s"list2: ${list2}")
     println(s"list3: ${list3}")
     println(s"list4: ${list4}")
   }
   

8. fold 折叠

   fold与reduce很像，只不过多了一个指定初始值参数.

   语法

   def fold[A1 >: A](z: A1)(op:(A1, A1) => A1): A1
   //简写形式:
   def fold(初始值)(op:(A1, A1) => A1)
   

   说明

   

   案例

    def main(args: Array[String]): Unit = {
     //1. 定义一个列表，包含以下元素：1,2,3,4,5,6,7,8,9,10
     val list1 = (1 to 10).toList
     //2. 假设初始化值是100, 使用fold计算所有元素的和
     //val list2 = list1.fold(100)((x, y) => x + y)
     //简写形式:
     val list2 = list1.fold(100)(_ + _)
     val list3 = list1.foldLeft(100)(_ + _)
     val list4 = list1.foldRight(100)(_ + _)
     println(s"list2: ${list2}")
     println(s"list3: ${list3}")
     println(s"list4: ${list4}")
   }