scala集合中的重要函数
集合高阶函数：map
map函数的语法
final def map[B](f: (A) ⇒ B): List[B]
//map函数只有1个参数，这个参数是一个函数类型
f: (A) ⇒ B：f就是参数函数
//f有1个参数：A：代表集合中的每个元素
//f的返回值：B：B是A处理以后的返回值
List[A].map = List[B]
A1 -> B1
A2 -> B2
……
ps:我有一个离线版的Scala API，需要的我私法你
map函数的功能
-
map函数用于将集合中的每个元素调用参数函数进行处理，并将每个元素处理的返回值放入一个新的集合中
-
集合中元素一对一的处理
-
处理逻辑：由传递的参数函数来决定了
- f：A => B
val f = (A) => {
//处理A逻辑
B
}
-
一般用于集合数据处理，这是最常用的处理函数
-
栗子
- 需求一：对以下集合进行处理，返回集合中每个元素的平方
val list1 = List(1,2,3,4,5,6,7,8,9,10)
scala> list1.map((numb) => {
| println(numb)
| numb*numb
| })
1
2
3
4
5
6
7
8
9
10
res0: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
scala> list1.map(numb => numb*numb)
res1: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
-
- 函数中：如果参数只有1个，调用时花括号可以省略
-
需求二：对以下集合进行处理，返回集合中每个字符串并在字符串的后面拼接字符串长度
val list2 = List("hadoop","","hive","hue"," ")scala> list2.map(word => word+"-"+word.length) res3: List[String] = List(hadoop-6, -0, hive-4, hue-3, " -1")
集合高阶函数：foreach
foreach函数的语法
final def foreach(f: (A) ⇒ Unit): Unit
//foreach有1个参数，是一个函数f
//f这个函数有1个参数：A：代表集合中的每个元素
//f这个函数没有返回值
foreach函数的功能与应用场景
-
用于将集合中的每个元素进行处理，但是没有返回值
-
一般用于将集合的数据进行输出或者保存：将数据结果打印或者写入外部文件系统
-
栗子
-
需求一：对以下集合进行处理，输出集合中的每个元素
val list1 = List(1,2,3,4,5,6,7,8,9,10)scala> list1.foreach(i => println(i)) 1 2 3 4 5 6 7 8 9 10 scala> list1.foreach(println(_)) 1 2 3 4 5 6 7 8 9 10 scala> list1.foreach(println) 1 2 3 4 5 6 7 8 9 10-
需求二：对以下集合进行处理，输出集合中每个字符串并在字符串的后面拼接字符串长度
val list2 = List("hadoop","","hive","hue"," ")scala> val list2 = List("hadoop","","hive","hue"," ") list2: List[String] = List(hadoop, "", hive, hue, " ") scala> list2.foreach(word => println(word+"\t"+word.length)) hadoop 6 0 hive 4 hue 3 1
-
集合高阶函数：flatMap
-
- flatMap函数的语法
final def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): List[B] //flatMap有1个参数f,是一个函数 //f这个函数有1个参数：A：集合中的每个元素 //f这个函数有返回值： GenTraversableOnce[B]，对每个A处理以后返回的结果，是一个集合，集合中有多个元素B //flatMap返回值是：List[B]：将每个A返回的集合进行合并 基本原理：f：调用每个元素进行map处理，map返回值是List，每个元素放回一个集合，最终每个元素处理的结果：List[List[B]] flatMap会将这个List[List[B]] 变成List[B] -
flatMap函数的功能
- 对集合中的每个元素调用map函数进行处理，根据参数函数的处理逻辑，将返回值中的每个集合进行扁平化
- 只有需要做扁平化处理，才调用flatMap
- map：一对一
- flatMap：多对一
- 每个元素调用一次map，每个map返回一个集合，将所有集合中的元素合并到一个集合中
- 对集合中的每个元素调用map函数进行处理，根据参数函数的处理逻辑，将返回值中的每个集合进行扁平化
-
栗子
-
需求一：对以下集合进行处理，将所有数字合并到一个集合中
val m1 = Map("key1"->"1,2,3","key2"->"4,5,6","key3"->"7,8,9")scala> m1.values res11: Iterable[String] = MapLike(1,2,3, 4,5,6, 7,8,9)
scala> m1.values.foreach(println)
1,2,3
4,5,6
7,8,9scala> m1.values.flatMap(x => x.split(",")).foreach(println)
1
2
3
4
5
6
7
8
9
```-
需求二：对以下集合进行处理，将所有单词放入一个集合中
val list5 = List("hadoop spark"," spark","hive hbase ","hue hue spark"," hue ")scala> list5.flatMap(line => line.split(" ")) res14: List[String] = List(hadoop, spark, "", spark, hive, hbase, hue, hue, spark, "", hue) scala> list5.flatMap(line => line.trim.split(" ")) res15: List[String] = List(hadoop, spark, spark, hive, hbase, hue, hue, spark, hue)
-
集合高阶函数：groupBy
-
groupBy函数的语法
def groupBy[K](f: (A) ⇒ K): Map[K, List[A]] //groupBy传递一个参数f：函数参数 //f有一个参数：A：每个元素 5 (key,value) (tup1,tup2,tupe3) //f有一个返回值：K：按照谁分组 //groupBy返回值：Map[K, List[A]]，每个KV代表一组 K：分组的那个组 V：List[A]，符合K的所有A的集合 -
groupBy函数的功能
- 对集合中的元素按照指定的条件进行分组
-
栗子
-
需求一：对以下集合进行处理，按照奇偶数进行分组
val list3 = List(2,4,6,8,9,7,5,3,1)scala> list3.groupBy( x => x%2==0).foreach(println) (false,List(9, 7, 5, 3, 1)) (true,List(2, 4, 6, 8)) -
需求二：对以下集合进行处理，按照地区进行分组
val m2 = Map(1->"shanghai",2->"beijing",3->"jiangsu",4->"anhui",5->"beijing",6->"anhui",7->"anhui",8->"shanghai",9->"beijing",10->"beijing")scala> m2.groupBy(tuple => tuple._2).foreach(println) (jiangsu,Map(3 -> jiangsu)) (shanghai,Map(1 -> shanghai, 8 -> shanghai)) (anhui,Map(6 -> anhui, 7 -> anhui, 4 -> anhui)) (beijing,Map(5 -> beijing, 10 -> beijing, 9 -> beijing, 2 -> beijing))
-
集合高阶函数：filter/filterNot
-
filter函数的语法
def filter(p: (A) ⇒ Boolean): List[A] //filter函数传递1个参数：p：函数 //p的参数：A：每个元素 //p的返回值：Boolean,一般是表达式的结果 //filter的返回值：List[A] :所有符合表达式的元素的集合 -
filter函数的功能
- 用于实现对集合中的数据进行过滤，将符合条件表达式的数据放入一个新的集合返回
-
filterNot函数的语法
def filterNot(p: (A) ⇒ Boolean): List[A] -
filterNot函数的功能
- 用于实现对集合中的数据进行过滤，将不符合条件表达式的数据放入一个新的集合返回
-
栗子
-
需求一：对以下集合进行处理，返回集合中所有的偶数
val list1 = List(1,2,3,4,5,6,7,8,9,10)scala> list1.filter( x => x % 2 == 0) res20: List[Int] = List(2, 4, 6, 8, 10)
scala> list1.filterNot(x => x % 2 != 0)
res21: List[Int] = List(2, 4, 6, 8, 10) -
-
需求二：对以下集合进行处理，过滤掉所有不是单词的元素
val list2 = List("hadoop","","hive","hue"," ")scala> list2.filter(word => word.trim.length > 0) res22: List[String] = List(hadoop, hive, hue) scala> list2.filter(_.trim.length > 0) res23: List[String] = List(hadoop, hive, hue)
集合高阶函数：sortWith/sortBy
-
Scala中的排序函数
- sorted：只能对数据进行整体升序排序
- sortWith：高阶函数
- sortBy：高阶函数，常用
-
sortWith函数的语法
def sortWith(lt: (A, A) ⇒ Boolean): List[A] //sortWith有一个参数：lt：函数 //lt传递两个参数：(A,A)：每次取集合中两个元素来处理 //lt返回值：表达式的Boolean值：判断大小的条件 //sortWith的返回值：List[A]:根据判断构建有序的结果 -
sortWith函数的功能
- 对集合中的元素进行两两比较，实现排序
-
栗子
-
集合
val list3 = List(2,4,6,8,9,7,5,3,1) -
需求一：对集合进行升序排序
scala> list3.sortWith((a,b) => a < b ) res24: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9) -
需求二：对集合进行降序排序
scala> list3.sortWith((a,b) => a > b ) res25: List[Int] = List(9, 8, 7, 6, 5, 4, 3, 2, 1)
-
-
sortBy函数的语法
def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): List[A] //sortBy传递一个参数f：函数 //f的参数：A：集合中的每个元素 //f的返回值：B：按照A中的什么进行排序 //sortBy返回的是排序好的结果 -
sortBy函数的功能
- 对集合中的元素进行排序，按照参数函数的返回值进行排序
-
栗子
-
集合
val list3 = List(2,4,6,8,9,7,5,3,1) val list4 = List(("zhangsan",20,"male"),("lisi",30,"female"),("wangwu",19,"male"))-
需求一：对list3集合进行升序排序
scala> list3.sortBy(x => x) res26: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9) -
需求二：对list3集合进行降序排序
scala> list3.sortBy(x => -x) res27: List[Int] = List(9, 8, 7, 6, 5, 4, 3, 2, 1) -
需求三：对list4集合按照年龄进行升序排序
scala> list4.sortBy(tuple => tuple._2) res28: List[(String, Int, String)] = List((wangwu,19,male), (zhangsan,20,male), (lisi,30,female)) -
需求四：对list4集合按照年龄进行降序排序
scala> list4.sortBy(tuple => -tuple._2) res29: List[(String, Int, String)] = List((lisi,30,female), (zhangsan,20,male), (wangwu,19,male))
-
-
集合聚合函数：reduce
- reduce函数的语法
def reduce(op: (A1, A1) ⇒ A1): A1
//reduce传递1个：op
//op传递2个参数：(T, A)
T：临时变量，用于存储中间结果，tmp的初始值为第一个元素
A：集合中的每个元素
//op返回值：A1：聚合的结果
//reduce返回值：A1：聚合的结果
-
reduce函数的功能
- 对集合中的元素进行聚合计算
-
栗子
-
需求一：对以下集合进行处理，计算所有元素之和
val list3 = List(2,4,6,8,9,7,5,3,1) -
需求二：对list3集合进行处理，计算所有元素的乘积
list3.reduce((tmp,item) => tmp*item) -
需求三：对list3集合进行处理，计算所有偶数之和
list3.reduce((tmp,item) => tmp+item) scala> list3.reduce((tmp,item) => { | println(s"tmp = ${tmp} item = ${item}") | tmp+item | }) tmp = 2 item = 4 tmp = 6 item = 6 tmp = 12 item = 8 tmp = 20 item = 9 tmp = 29 item = 7 tmp = 36 item = 5 tmp = 41 item = 3 tmp = 44 item = 1 res32: Int = 45 scala> list3.reduce(_+_) res35: Int = 45
-
-
reduceLeft、reduceRight的功能与用法
-
语法
def reduce(op: (A1, A1) ⇒ A1): A1 def reduceLeft(f: (B, A) ⇒ B): B def reduceRight(op: (A, B) ⇒ B): B
-
-
功能
- reduceLeft的功能与reduce是一致的：左边参数代表tmp临时值，右边参数代表元素，从左聚合到右
- reduceRight：右边参数代表tmp临时值，左边参数代表元素，从右聚合到左
-
栗子
list3.reduceLeft((tmp,item) => { println(s"tmp = ${tmp} item = ${item}") tmp+item }) list3.reduceRight((item,tmp) => { println(s"tmp = ${tmp} item = ${item}") tmp+item })
集合聚合函数：fold
-
- fold函数的语法
def fold(z: A1)(op: (A1, A1) ⇒ A1): A1 //fold：两个参数 //z：临时变量的初始值 //op：函数:聚合逻辑 (T,A) => B T：临时变量 A：集合中的每个元素 B：聚合的结果 -
fold函数的功能
- 对集合中的元素进行聚合计算，需要指定初始值
-
栗子
-
需求一：对以下集合进行处理
val list3 = List(2,4,6,8,9,7,5,3,1) -
需求二：对list3集合进行处理，计算所有元素的乘积
list3.fold(1)((tmp,item) => tmp*item) list3.fold(1)((tmp,item) => { println(s"tmp = ${tmp} item = ${item}") tmp*item }) -
需求三：对list3集合进行处理，计算所有元素之和/计算所有偶数之和
list3.fold(0)((tmp,item) => tmp+item) list3.fold(0)((tmp,item) => { if(item % 2 == 0) tmp+item else tmp }) -
fold函数与reduce函数的区别
- 比reduce多了一个初始值
-
1163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
