第一章.函数式编程

面向对象编程:

  • 解决问题,分解对象,行为,属性,然后通过对象的关系以及行为的调用来解决问题
  • 对象: 用户
  • 行为: 登录,连接Jdbc,读取数据库
  • 属性: 用户名,密码
  • Scala语言是一个完全面向对象编程语言,万物皆对象

函数式编程:

  • 解决问题时,将问题分解成一个一个的步骤,将每个步骤进行封装(函数),通过调用这些封装好的步骤,解决问题
  • 例如: 请求->用户名,密码->连接jdbc->读取数据库

在Scala中函数式编程和面向对象编程融合在一起了

1.方法定义语法

  1. package com.atguigu.chapter05
  3. object $01_MethodDefined {
  4.   /**
  5.    * 方法定义语法: def 方法名(参数名:参数类型,....):返回值类型={方法体}
  6.    */
  7.   def main(args:Array[String]): Unit={
  8.     println(add(10,20))
  9.   }
  10.   def add(x:Int,y:Int):Int={
  11.     x+y
  12.   }
  14. }

2.方法简化的原则

  1. package com.atguigu.chapter05
  3. object $02_MethodSample {
  4.   /**
  5.    * 方法简化的原则:
  6.    *    1.如果方法使用方法体的块表达式的结果值作为方法的返回值,此时定义方法的时候方法的返回值类型可以省略
  7.    *      注意:如果方法体中有return关键字,方法的返回值类型必须定义
  8.    *    2.如果方法体只有一行语句,那么方法体的{}可以忽略
  9.    *    3.如果方法不需要返回值,那么定义方法的时候=可以忽略  [=与{}不能同时忽略]
  10.    */
  11.   def main(args:Array[String]):Unit={
  12.     println(add2(10,20))
  13.     println(add3(10,20))
  14.     printMsg2("hello")
  15.     //1.如果定义方法的时候没有(),那么在调用方法的时候()也不能带上
  16.     hello2
  17.     //2.如果定义方法的时候有(),那么在调用方法的时候()可有可无
  18.     hello()
  19.     hello
  20.   }
  22.   //标准定义形式
  23.   def add(x:Int,y:Int):Int={
  24.     return x + y
  25.   }
  26.   //1.如果方法使用方法体的块表达式的结果值作为方法的返回值,此时定义方法的时候,方法的返回值类型可以忽略
  27.   def add2(x:Int,y:Int)={
  28.     x + y
  29.   }
  30.   //2.如果方法体只有一行语句,那么方法体的{}可以忽略
  31.   def add3(x:Int,y:Int) = x + y
  33.   //标准形式
  34.   def printMsg(msg:String):Unit={
  35.     println(s"msg=${msg}")
  36.   }
  37.   //3.如果方法不需要返回值,那么定义方法的时候=可以忽略[=与{}不能同时忽略]
  38.   def printMsg2(msg:String){
  39.     println(s"msg=${msg}")
  40.   }
  41.   //标准形式
  42.   def hello():Unit={
  43.     println("hello...........")
  44.   }
  45.   //4.如果方法不需要参数,那么定义方法的时候()可以忽略
  46.   def hello2{
  47.     println("hello2...........")
  48.   }
  50. }

3.方法参数

  1. object $03_MethodParam {
  2.   /**
  3.    * scala方法的参数
  4.    *    1.默认值参数,在调用方法的时候有默认值的参数可以不用传参数[默认值参数一般放在参数列表最后面]
  5.    *        语法: def 方法名(参数名:类型[默认值],.....):返回值类型 = {方法体}
  6.    *    2.带名参数:在调用方法的时候指定将参数值传给哪个参数
  7.    *    3.可变参数:在调用方法的时候传递的参数的个数不固定
  8.    *        语法: def 方法名(参数名:类型,...,参数名:类型*):返回值类型={方法体}
  9.    *        scala可变参数不能直接传递集合,如果想要将集合所有元素传递给可变参数,可以通过 集合名:_*的方式传递
  10.    */
  11.     def main(args:Array[String]):Unit ={
  12.       println(add(10))
  13.       //带名参数
  14.       println(add(x=4,y=6))
  15.       val arr = Array[Int](10,20,30,40)
  16.       println(sum(10,20,arr:_*))
  17.     }
  22.   //默认值参数
  23.   def add(x:Int,y:Int=30) = x + y
  24.   //可变参数
  25.   def sum(x:Int,y:Int,z:Int*) = x + y + z.sum
  27. }

需求: 统计前七天的用户注册数

  1. object demo{
  3.   //需求:统计前七天的用户注册数
  4.   def main(args: Array[String]): Unit = {
  5.     val paths = getPaths(7, "/user/hive/warehouse/user_info")
  6.     println(paths)
  8.     println("----------------------------------")
  9.     readPaths(paths)
  10.   }
  12.   def getPaths(n:Int,pathPrefix:String)={
  13.     //获取当前日期
  14.     val currentDate = LocalDateTime.now()
  15.     for(i<-1 to n) yield{
  16.       //日期加减法
  17.       val time = currentDate.plusDays(-i)
  18.       //格式化时间
  19.       val timeStr = time.format(DateTimeFormatter.ofPattern("yyyyMMdd"))
  20.       s"${pathPrefix}/${timeStr}"
  21.     }
  22.   }
  24.   def readPaths(paths:IndexedSeq[String]):Unit={
  25.     for (path <- paths) {
  26.       println(path)
  27.     }
  28.   }
  31. }

4.函数定义语法

  1. package com.atguigu.chapter05
  3. object $04_FunctionDefiend {
  5.   /**
  6.    * 方法就是函数,函数也是对象
  7.    * 函数的定义语法: val 函数名 = (参数名:参数类型,...) => {函数体}
  8.    * 函数的简化:如果函数体中只有一行语句,那么函数体{}可以忽略
  9.    * 函数是对象,函数的类型:(参数类型,....)=>返回值类型
  10.    *
  11.    */
  13.   def main(args: Array[String]): Unit = {
  14.     println(func(10,20))
  15.     println(func.apply(10,20))
  16.     val name2 = name
  17.     val func3 = func
  18.     hello()
  19.     println(hello)
  20.     println(func3(30,40))
  22.   }
  24.   val func=(x:Int,y:Int) => {x + y}
  25.   val name:String = "zhangsan"
  26.   val hello=()=>{
  27.     println("...........")
  28.   }
  30.   val func2 = new Function2[Int,Int,Int]{
  31.     override def apply(v1:Int,v2:Int):Int=v1+v2
  33.   }
  36. }

5.方法与函数的区别

  1. package com.atguigu.chapter05
  3. object $05_MethodAndFunction {
  4.   /**
  5.    * 方法与函数的区别
  6.    *      1.方法定义在类中的时候可以重载,函数是对象,函数名就是对象的引用,所以不能重载
  7.    *      2.方法存储在方法区中,函数是对象存储在堆中
  8.    * 方法和函数的关系
  9.    *      1.方法名可以转成函数,可以通过 方法名 _ 的方式转成函数
  10.    *      2.方法如果定义在方法中就是函数,不能重载的
  11.    */
  12.   def main(args: Array[String]): Unit = {
  13.      println(func(10,20))
  14.     println(add(10,20,30))
  15.     //方法转函数
  16.     val func2 = add _
  17.     println(func2(10,20,30))
  19.   }
  21.   val func = (x:Int,y:Int)=>x + y
  22.   // func = (x:Int,y:Int,z:Int)=>x + y + z
  23.   //def add(x:Int,y:Int)= x+y
  24.   def add(x:Int,y:Int,z:Int) = x + y + z
  26. }

6.高阶函数的定义

  1. package com.atguigu.chapter05
  3. object $06_HIghFunction {
  4.   /**
  5.    * 高阶函数:以函数作为参数或者返回值的方法/函数称之为高阶函数
  6.    *
  7.    */
  8.   def main(args: Array[String]): Unit = {
  9.     val func =(x:Int,y:Int)=>{
  10.       x + y
  11.     }
  12.     println(add(10,20,func))
  13.   }
  15.   //高阶函数
  16.   def add(x:Int,y:Int,func:(Int,Int)=>Int)={
  17.     func(x,y)
  18.   }
  20. }

7.高阶函数的简化

  1. package com.atguigu.chapter05
  3. object $07_HightFunctionSample {
  4.   /**
  5.    * 高阶函数的简化:
  6.    *    1.可以直接将函数的值传给参数
  7.    *    2.函数的参数类型可以省略
  8.    *    3.如果函数的参数在函数体中只使用了一次可以用_代替
  9.    *          注意:以下情况下不能以_代替
  10.    *          1.函数体中参数的使用顺序与定义顺序不一致的时候不能用_代替[第N个下划线代表函数第N个参数]<针对函数有多个参数的情况>
  11.    *          2.如果函数只有一个参数,在函数体中没有做任何操作,直接返回参数本身,此时不能用_代替<针对函数只有一个参数的情况>
  12.    *          3.如果函数的参数体中有嵌套,函数的参数在嵌套中以表达式存在,此时不能用_简化
  13.    *    4.如果函数只有一个参数,函数的参数列表的()可以省略
  14.    */
  15.   def main(args: Array[String]): Unit = {
  16.     val func = (x:Int,y:Int) => x * y
  17.     println(add(10,20,func))
  18.     //1.可以直接将函数的值传给参数
  19.     println(add(10,20,(x:Int,y:Int)=>x * y))
  20.     //2.函数的参数类型可以省略
  21.     println(add(10,20,(x,y)=>x * y))
  22.     //3.如果函数的参数在函数体中只使用了一次可以用_代替
  23.     println(add(10,20,_ * _))
  24.     //
  25.     println(add(10,20,(x,y)=>y-x))
  26.     //1.函数体中参数的使用顺序与定义顺序不一致时不能用_代替
  27.     //println(add(10,20,_-_))
  28.     //2.如果函数只有一个参数,在函数体中没有做任何操作,直接返回函数本身,此时不能用_代替
  29.     println(add2(10,(x:Int)=>x))
  30.     //println(add2(10,_))
  31.     //3.如果函数体中有嵌套,函数的参数在嵌套中以表达式形式存在,此时不能用_代替
  32.     println(add2(10,(x:Int)=>(x+1)*10))
  33.     //println(add2(10,(_+1)*10))
  34.     //4.如果函数只有一个参数,函数的参数列表的()可以省略
  35.     println(add2(10,x=>(x+1)*10))
  36.   }
  37.   def add(x:Int,y:Int,func:(Int,Int)=>Int)={
  38.     func(x,y)
  39.   }
  40.   def add2(x:Int,func:Int=>Int) =func(x)
  41. }

8.匿名函数

  1. package com.atguigu.chapter05
  3. object $08_NoNameFunction {
  4.   /**
  5.    * 匿名函数:没有函数名的函数称之为匿名函数
  6.    * 匿名函数一般不单独使用,一般作为高阶函数的参数值传递
  7.    *
  8.    */
  9.   def main(args: Array[String]): Unit = {
  10.       val func = (x:Int) => x+10
  11.     println(func(20))
  12.     println(add(100,func))
  13.     //匿名函数一般不单独使用,一般作为高阶函数的参数值传递
  14.     println(add(100,_+10))
  16.   }
  17.   def add(x:Int,func:Int=>Int)=func(x)
  19. }

9.递归

  1. package com.atguigu.chapter05
  3. object $09_Recursion {
  4.   /**
  5.    * 递归:自己调用自己
  6.    * 递归必须满足两个条件:
  7.    *     1.必须要有退出条件
  8.    *     2.必须定义返回值类型
  9.    */
  10.   def main(args: Array[String]): Unit = {
  11.     println(func(5))
  12.     println(m1(5))
  14.   }
  15.   val func:Int =>Int=(n:Int)=>{
  16.     if(n==1) 1
  17.     else n * func(n-1)
  18.   }
  19.   /*val func=(n:Int) =>{
  20.     if(n==1) 1
  21.     else n * func(n-1)
  22.   }*/
  23.   def m1(n:Int):Int={
  24.     //必须有退出条件
  25.     if(n==1) 1
  26.     else n * m1(n-1)
  27.   }
  28. }

10.柯里化

  1. package com.atguigu.chapter05
  3. object $10_Currying {
  4.   /**
  5.    * 柯里化:有多个参数列表的方法称之为柯里化
  6.    */
  7.   def main(args: Array[String]): Unit = {
  8.     println(m1(10,20)(30)(40))
  9.     println(m2(10,20,30,40))
  11.   }
  14.   /**
  15.    * 柯里化
  16.    */
  17.   def m1(x:Int,y:Int)(z:Int)(a:Int)=x+y+z+a
  19.   def m2(x:Int,y:Int,z:Int,a:Int)=x+y+z+a
  20. }

11.闭包

  1. package com.atguigu.chapter05
  3. object $11_ClosePackage {
  4.   /**
  5.    * 闭包:函数体中使用了外部变量的函数称之为闭包
  6.    */
  8.   def main(args: Array[String]): Unit = {
  9.     println(func(10))
  10.   }
  11.   val y =20
  12.   //闭包函数
  13.   val func =(x:Int)=>{
  14.     x + y
  15.   }
  17. }

12.惰性求值

  1. package com.atguigu.chapter05
  3. object $12_Lazy {
  4.   /**
  5.    * 惰性求值:只有变量在真正使用的时候才会初始化
  6.    * 语法:lazy val 变量名:类型 = 值
  7.    */
  8.   def main(args: Array[String]): Unit = {
  9.     val name = "zhangsan"
  10.     println(s"name=${name}")
  11.     lazy val age =20
  12.     println(s"age=${age}")
  13.   }
  14. }

13.控制抽象

  1. package com.atguigu.chapter05
  3. object $18_ControlAbstract {
  4.   /**
  5.    * 控制抽象:
  6.    * 语法:  => 返回值类型
  7.    * 控制抽象不能单独使用,只能作为方法的参数类型存在
  8.    * 控制抽象其实就是一个块表达式,后续可以当做函数调用,只是在调用控制抽象时不能带上()
  9.    */
  10.   def main(args: Array[String]): Unit = {
  11.      val a ={
  12.        println("---------------")
  13.        10+20
  14.      }
  15.     m1(a)
  16.     m1(a)
  17.     m1(a)
  18.       val func=()=>{
  19.         println("=====================")
  20.         10+20
  21.       }
  22.     m2(func)
  23.     m2(func)
  24.     m2(func)
  26.     m3({
  27.       println("***************")
  28.       10+20
  29.     })
  30.   }
  31.   def m1(x:Int) =x * x
  32.   def m2(func:()=>Int)= func() * func()
  33.   def m3(func: =>Int)={
  34.     func
  35.     func
  36.     func
  37.   }
  39. }

第二章.练习

1.练习一

  1. 需求:根据指定规则对数组中的每个元素操作
  2. 数据: Array[String]("hello","spark","java","hadoop")
  3. 规则: 获取每个元素的长度 [可变]
  4. 结果: Array[Int](5,5,4,6)
  1. package com.atguigu.chapter05
  3. object $13_HomeWork01 {
  4.   /*
  5.   * 需求: 根据指定规则对数组中的每个元素操作
  7. - 数据: Array[String]("hello","spark","java","hadoop")
  8. - 规则: 获取每个元素的长度 [可变]
  9. - 结果: Array[Int](5,5,4,6)
  10.   * */
  11.   def main(args: Array[String]): Unit = {
  12.     val data = Array[String]("hello","spark","java","hadoop")
  13.     val func = (x:String) =>x.length
  14.     val arr = map(data,func)
  15.     println(arr.toList)
  17.   }
  19.   def map(data:Array[String],func:String => Any)={
  20.     for(element<-data) yield{
  21.       func(element)
  22.     }
  23.   }
  25. }

2.练习二

  1. 根据指定规则对数组进行过滤
  2. 数据: Array[Int](1,4,3,7,6,10,9)
  3. 规则: 保留偶数数据 [可变]
  4. 结果: Array[Int](4,6,10)
  1. package com.atguigu.chapter05
  3. object $14_HomeWork02 {
  4.   /**
  5.    * 根据指定规则对数组进行过滤
  6.      数据: Array[Int](1,4,3,7,6,10,9)
  7.      规则: 保留偶数数据 [可变]
  8.      结果: Array[Int](4,6,10)
  9.    */
  10.   def main(args: Array[String]): Unit = {
  11.     val data = Array[Int](1, 4, 3, 7, 6, 10, 9)
  13.     val func = (data:Array[Int]) => {
  14.       val arr = data.filter(x => x%2==0)
  15.        arr.toList
  18.     }
  19.     val result = map(data,func)
  21.     println(result)
  22.   }
  24.   def map(data:Array[Int],func:Array[Int]=>Any)={
  25.     func(data)
  26.   }
  29. }

3.练习三

  1. 根据指定规则对数组所有元素进行聚合
  2. 数据: Array[Int](1,4,3,7,6,10,9)
  3. 规则： 求和 [可变]
  4. 结果: 40
  1. package com.atguigu.chapter05
  3. object $15_HomeWork03 {
  4.   /**
  5.    * 根据指定规则对数组所有元素进行聚合
  6.      数据: Array[Int](1,4,3,7,6,10,9)
  7.      规则： 求和 [可变]
  8.      结果: 40
  9.    */
  10.   def main(args: Array[String]): Unit = {
  11.        val sum =0
  12.        val data= Array[Int](1,4,3,7,6,10,9)
  13.        val func=(data:Array[Int])=>data.sum
  14.        val result = map(data,func)
  15.        println(result)
  17.   }
  18.      def map(data:Array[Int],func:Array[Int]=>Int)={
  19.           func(data)
  20.      }
  22. }

4.练习四

  1. 根据指定规则对数组中的元素进行分组
  2. 数据: Array[String]("zhangsan man shenzhen","lisi woman beijing","zhaoliu man beijing")
  3. 规则: 按照性别分组 [可变]
  4. 结果: Map( man-> List( "zhangsan man shenzhen", "zhaoliu man beijing") , woman -> List( "lisi woman beijing" ) )
  1. package com.atguigu.chapter05
  3. import java.util
  5. object $16_HomeWork04 {
  7.   /**
  8.    * 根据指定规则对数组中的元素进行分组
  9.     数据: Array[String]("zhangsan man shenzhen","lisi woman beijing","zhaoliu man beijing")
  10.     规则: 按照性别分组 [可变]
  11.     结果: Map( man-> List( "zhangsan man shenzhen", "zhaoliu man beijing") , woman -> List( "lisi woman beijing" ) )
  12.    */
  13.   def main(args: Array[String]): Unit = {
  14.       val data = Array[String]( "zhangsan man shenzhen","lisi woman beijing","zhaoliu man beijing")
  15.       val func =(x:String)=>x.split(" ")(1)
  16.       println(groupBy(data, func))
  18.   }
  19.     def groupBy(data:Array[String],func:String=>Any)={
  20.         //定义一个容器装载分组的结果
  21.         val map = new util.HashMap[Any,util.List[String]]()
  22.         //遍历
  23.         for(element<-data){
  24.             //得到分组的key
  25.             val key = func(element)
  26.             //判断key是否存在,如果存在则直接将当前元素添加到key对应的list中
  27.             if(map.containsKey(key)){
  28.                 val list = map.get(key)
  29.                 list.add(element)
  30.             }
  31.             if(!map.containsKey(key)){
  32.                 val list = new util.ArrayList[String]()
  33.                 list.add(element)
  34.                 map.put(key,list)
  35.             }
  36.         }
  37.         map
  38.     }
  40. }

5.练习五

  1. 根据指定规则获取数组中的最大值的信息
  2. 数据: Array[String]("zhangsan 20 1500","lisi 35 2000","zhaoliu 18 4500")
  3. 规则: 获取年龄最大的人的信息 [可变]
  4. 结果: "lisi 35 2000"
  1. package com.atguigu.chapter05
  3. object $17_HomeWork05 {
  4.   /*根据指定规则获取数组中的最大值的信息
  5.   数据: Array[String]("zhangsan 20 1500","lisi 35 2000","zhaoliu 18 4500")
  6.   规则: 获取年龄最大的人的信息 [可变]
  7.   结果: "lisi 35 2000"*/
  8.   def main(args: Array[String]): Unit = {
  9.     val data = Array[String]("zhangsan 20 1500", "lisi 35 2000", "zhaoliu 18 4500")
  10.     val func = (x: String) => {
  11.       x.split(" ")(1).toInt
  13.     }
  14.     println(maxBy(data, func))
  17.   }
  19.   def maxBy(data:Array[String],func:String=>Int)={
  20.     //定义中间变量
  21.     var tmp = func(data(0))
  22.     var result:String = null
  23.     for (elem <- data) {
  24.       val key = func(elem)
  25.       if(key >= tmp){
  26.         tmp = key
  27.         result =elem
  28.       }
  29.     }
  30.     result
  31.   }
  32. }