网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
1、sorted默认排序
//定义一个List集合
scala> val list=List(5,1,2,4,3)
list: List[Int] = List(5, 1, 2, 4, 3)
//默认就是升序
scala> list.sorted
res30: List[Int] = List(1, 2, 3, 4, 5)
//生成新的List；原List不变
scala> list
res5: List[Int] = List(5, 1, 2, 4, 3)
2、sortBy指定字段排序
根据传入的函数转换后，再进行排序
def sortBy[B](f: (A) ⇒ B): List[A]
| sortBy方法 | API | 说明 |
|---|---|---|
| 泛型 | [B] | 按照什么类型来进行排序 |
| 参数 | f: (A) ⇒ B | 传入函数对象，接收一个集合类型的元素参数 返回B类型的元素进行排序 |
| 返回值 | List[A] | 返回排序后的列表 |
//定义一个List集合
scala> val list=List("1 hadoop","3 flink","2 spark")
list: List[String] = List(1 hadoop, 3 flink, 2 spark)
//按照单词的首字母进行排序
scala> list.sortBy(x=>x.split(" ")(1))
res33: List[String] = List(3 flink, 1 hadoop, 2 spark)
reverse可以反转
3、sortWith自定义排序
自定义排序，根据函数来定义排序规则
def sortWith(lt: (A, A) ⇒ Boolean): List[A]
| sortWith方法 | API | 说明 |
|---|---|---|
| 参数 | lt: (A, A) ⇒ Boolean | 传入一个比较大小的函数对象，接收两个集合类型的元素参数，返回两个元素大小，小于返回true，大于返回false |
| 返回值 | List[A] | 返回排序后的列表 |
scala> val list = List(2,3,1,6,4,5)
a: List[Int] = List(2, 3, 1, 6, 4, 5)
//降序
scala> list.sortWith((x, y)=>x>y)
res35: List[Int] = List(6, 5, 4, 3, 2, 1)
list5.sortWith(_ > _)
//升序
scala> list.sortWith((x,y)=>x<y)
res36: List[Int] = List(1, 2, 3, 4, 5, 6)
//字典序升序
List("Hive", "hive", "hadoop", "Spark").sortWith(_.compareTo(_) < 0)
6、分组 groupBy
首先集合的元素得是kv对的；如果要将数据按照某值分组来进行统计分析，就需要使用到分组方法groupBy表示按照函数将列表分成不同的组
def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]
| groupBy方法 | API | 说明 |
|---|---|---|
| 泛型 | [K] | 分组字段的类型 |
| 参数 | f: (A) ⇒ K | 传入一个函数对象，接收集合元素类型的参数 返回一个K类型的key，这个key会用来进行分组，相同的key放在一组中 |
| 返回值 | Map[K, List[A]] | 返回一个映射，K为分组字段，List为这个分组字段对应的一组数据 |
scala> val a = List("张三"->"男", "李四"->"女", "王五"->"男")
a: List[(String, String)] = List((张三,男), (李四,女), (王五,男))
// 按照性别分组
scala> a.groupBy(_._2)
res0: scala.collection.immutable.Map[String,List[(String, String)]] = Map(男 -> List((张三,男), (王五,男)),
女 -> List((李四,女)))
// 将分组后的映射转换为性别/人数元组列表
scala> res0.map(x => x._1 -> x._2.size)
res3: scala.collection.immutable.Map[String,Int] = Map(男 -> 2, 女 -> 1)
//求每个省份有多少人
val b = List("张三"->("男", "北京"), "李四"->("女", "河北"), "王五"->("男", "北京"))
scala> b.groupBy(_._2._2).map(x => (x._1, x._2.size))
res14: scala.collection.immutable.Map[String,Int] = Map(北京 -> 2, 河北 -> 1)
7、聚合 reduce
reduce表示将列表，传入一个函数进行聚合计算
def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
| reduce方法 | API | 说明 |
|---|---|---|
| 泛型 | [A1 >: A] | （下界）A1必须是集合元素类型的父类或本类型 |
| 参数 | op: (A1, A1) ⇒ A1 | 传入函数对象，用来不断进行聚合操作 第一个A1类型参数为当前聚合后的变量，第二个A1类型参数为当前要进行聚合的元素 |
| 返回值 | A1 | 列表最终聚合为一个元素 |
scala> val a = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> a.reduce((x,y) => x + y)
res2: Int = 55
// 第一个下划线表示第一个参数，就是历史的聚合数据结果
// 第二个下划线表示第二个参数，就是当前要聚合的数据元素
scala> a.reduce(_ + _)
res3: Int = 55
// 与reduce一样，从左往右计算
scala> a.reduceLeft(_ + _)
res4: Int = 55
// 从右往左聚合计算
scala> a.reduceRight(_ + _)
res5: Int = 55
8、折叠 fold
fold与reduce很像，但是多了一个指定初始值参数
def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
| reduce方法 | API | 说明 |
|---|---|---|
| 泛型 | [A1 >: A] | （下界）A1必须是集合元素类型的父类或本类型 |
| 参数1 | z: A1 | 初始值 |
| 参数2 | op: (A1, A1) ⇒ A1 | 传入函数对象，用来不断进行折叠操作 第一个A1类型参数为当前折叠后的变量，第二个A1类型参数为当前要进行折叠的元素 |
| 返回值 | A1 | 列表最终折叠为一个元素 |
//定义一个List集合
scala> val a = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
a: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
//求和
scala> a.sum
res1: Int = 55
//给定一个初始值，，折叠求和
scala> a.fold(0)(_+_)
res2: Int = 55
scala> a.fold(10)(_+_)
res3: Int = 65
//从左往右
scala> a.foldLeft(10)(_+_)
res4: Int = 65
//从右往左
scala> a.foldRight(10)(_+_)
res5: Int = 65
//fold和foldLet效果一致，表示从左往右计算
//foldRight表示从右往左计算
二、高阶函数
高阶函数就是使用函数值作为参数，或者返回值为函数值的“函数”和“方法“。
1、函数值作为参数
//定义一个数组
scala> val array=Array(1, 2, 3, 4, 5)
array: Array[Int] = Array(1, 2, 3, 4, 5)
//定义一个函数
scala> val func = (x: Int) => x*10
func: Int => Int = <function1>
//完整的写法
val func: Int => Int = {
x => x*10
}
//函数作为参数传递到方法中
scala> array.map(func)
res0: Array[Int] = Array(10, 20, 30, 40, 50)
2、匿名函数
一个没有名称的函数，可以直接作为参数传递到方法中
//定义一个数组
scala> val array=Array(1, 2, 3, 4, 5)
array: Array[Int] = Array(1, 2, 3, 4, 5)
//定义一个没有名称的函数----匿名函数
scala> array.map(x => x*10)
res1: Array[Int] = Array(10, 20, 30, 40, 50)
//简写写法
array.map(_ * 10)
3、柯里化
方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的函数，该函数接收剩余的参数列表作为其参数。这被称为柯里化。
scala> def add1(x: Int, y: Int): Int = x + y
add1: (x: Int, y: Int)Int
scala> add1(1, 2)
res2: Int = 3
scala> def add2(x: Int) = (y: Int) => x + y
add2: (x: Int)Int => Int
scala> val func1 = add2(2)
func1: Int => Int = <function1>
scala> func1(3)
res3: Int = 5
//直接写
scala> add2(2)(3)
res4: Int = 5
//柯里化的函数写法
scala> def add3(x: Int)(y: Int) = x + y
add3: (x: Int)(y: Int)Int
//直接使用
scala> add3(2)(3)
res6: Int = 5
//又一个示例，练习一下这多种写法
scala> def getAddress(a:String):(String,String)=>String={
| (b:String,c:String)=>a+"-"+b+"-"+c
| }
getAddress: (a: String)(String, String) => String
scala> val f1=getAddress("china")
f1: (String, String) => String = <function2>
scala> f1("HangZhou", "xihu")
res7: String = china-HangZhou-xihu
//这里也可以这样去定义方法
scala> def getAddress(a:String)(b:String,c:String): String={
| a+"-"+b+"-"+c
| }
getAddress: (a: String)(b: String, c: String)String
//调用
scala> getAddress("china")("HangZhou", "xihu")
res3: String = china-HangZhou-xihu
scala> val func = getAddress("china") _
func: (String, String) => String = <function2>
scala> func("HangZhou", "xihu")
res2: String = china-HangZhou-xihu
//向下面这些操作都是使用到了柯里化
List(1, 2, 3, 4).fold(0)(_ + _)
List(1, 2, 3, 4).foldLeft(0)(_ + _)
List(1, 2, 3, 4).foldRight(0)(_ + _)
4、闭包
如下面示例，定义的函数func，它的返回值是依赖于不在函数作用域的一个变量，后期必须要要获取到这个变量才能执行。这种形式叫做闭包。当外部变量的值发生变化时，scala闭包也可以捕获这种变化。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
la闭包也可以捕获这种变化。
[外链图片转存中…(img-LFRSuuPW-1715522521826)]
[外链图片转存中…(img-veO6F4mo-1715522521826)]
[外链图片转存中…(img-IDHrki8r-1715522521827)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
扫一扫
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
