scala part3 黑马，函数式编程（重要）

函数式编程指的是方法的参数列表可以接受函数对象

1 foreach（遍历集合）

格式

def foreach(f:(A)=> Unit) : Unit

//简写
def foreach(函数)

def main(args: Array[String]): Unit = {
    val list1 = List(1,2,3,4)
    list1.foreach((x:Int) => {println(x)})

    //参数只有一个，类型可以通过类型推断
    list1.foreach(x => {println(x)})

    //函数体只有一句话
    list1.foreach(x => println(x))

    //当函数参数之在函数体中出现一次且函数体没有嵌套调用时，可以使用下划线来简化函数定义
    list1.foreach(println(_))

  }

2 map（将一种数据类型转换为另一种数据类型的过程，叫映射，和之前的那个Map不同）

格式

def map[B](f:(A) => B): TraversableOnce[B]

//简写形式
def map(函数对象)

    val list2 = list1.map((x:Int) => {"*" * x})
    println(s"list2: ${list2}")

    //参数只有一个，类型可以通过类型推断
    val list3 = list1.map(x => {"*" * x})
    println(s"list2: ${list3}")

    //函数体只有一句话
    val list4 = list1.map(x => "*" * x)
    println(s"list2: ${list4}")

    val list5 = list1.map("*" * _)
    println(s"list2: ${list5}")

3 flatMap

格式

def flatMap[B](f:(A) => GenTraversableOnce[B]): TraversableOnce[B]

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

    val list1 = List("hadoop hive sqoop","hbase zookeeper")
    val list2 = list1.map(_.split(" "))
    val list3 = list2.flatten
    
    //flatMap，就是先map再flatten
    val list4 = list1.flatMap(_.split(" "))

4 filter（过滤出符合条件的元素，（不符合条件的不要））

格式

def filter(f:(A) => Boolean): TraversableOnce[A]

//简化为
def filter(f:(A) => 筛选条件)

val list1 = (1 to 9).toList
val list2 = list1.filter(x => x % 2 == 0)

5 sorted，sortBy（根据指定字段排序），sortWith（自定义排序）

val list1 = List(3,1,4,2,6)
//增序
val list2 = list1.sorted
//降序
val list3 = list2.reverse

val list1 = List("01 hadoop","02 zookeeper","03 hive")
val list2 = list1.sortBy(x => x.split(" ")(1))

sortWith格式

def sortWith(f: (A, A) => Boolean): List[A]

//简写形式
def sortWith(函数对象：表示自定义的比较规则)

val list1 = List(2,3,1,6,4,5)
val list2 = list1.sortWith((x,y) => 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) => 具体的分组代码)

val list1 = List("刘德华" -> "男","刘亦菲" -> "女","胡歌" -> "男")
val map1 = list1.groupBy(x => x._2)
    
//这里x出现了两次，不能被下划线替代
val map2 = map1.map(x => x._1 -> x._2.size)
println(map2)

7 reduce（聚合操作）

格式

(A1的类型要么与A相等，要么是A的父类)
def reduce[A1 >: A](op:(A1, A1) => A1):A1

//简写形式
def reduce(op:(A1, A1) => A1)

（reduce和reduceLeft一样，从左往右计算。reduceRight从右往左计算）

    val list2 = list1.reduce((x,y) => x + y)
    val list2 = list1.reduce(_ + _)
    println(s"list2: ${list2}")
    val list3 = list1.reduceLeft(_ + _)
    val list4 = list1.reduceRight(_ + _)

//如果是相减操作，left和right结果不一样

left
1-2-3-4-5-6-7-8-9-10
得-53

right
9-10
8-(9-10)
7-(8-(9-10))
...
得-5

8 fold（折叠）

格式

def fold[A1 -> A](op:(A1,A1)=>A1):A1

//简写
def fold(初始值)(op:(A1,A1)=>A1)

val list1 = (1 to 10).toList

val list2 = list1.fold(100)((x,y) => x + y)
val list2 = list1.fold(100)(_ + _)

137

scala part3 黑马，函数式编程（重要）

猜你喜欢