大数据挖掘之Scala零基础学习（一）

第5章函数

5.1函数

程序代码：

object section5_1 extends App {

 // def gcd(x:Int,y:Int):Int=if(x%y==0) y else gcd(y,x%y)

  

  //def关键字声明函数  gcd为函数名  x,y为函数参数  ：Int为返回值类型

  def gcd(x:Int,y:Int):Int={

    if(x%y==0)

return y       //return关键字不能省略

    else

      return gcd(y,x%y)

  }

  val x=gcd(5,20)

  println(s"x的值是$x")

  

}

测试效果：

5.2值函数

Scala语言中函数也是对象也可以像变量一样被赋值，即值函数

注：=>为函数映射符，就是将左边的某种类型转换成右边的某种类型

object section5_2 extends App {

  val sum=(x:Int,y:Int)=>{

  println(x+y)

  x+y    //函数返回值

  }

  val x=sum(5,6)

  println(s"x的值$x")

  

  val y=(x:Double)=>{

    x*2

  }

  val m=y(3)

   println(s"m的值$m")

   

   val arrint=Array(1,2,3,4)

   //定义一个值函数

   val increament=(x:Int)=>x+1         

  //使用时直接将increament作为map函数的参数使用      

  val result=arrint.map(increament)       //等同于arrint.map(_+1)

   println(result.mkString("|"))

   

   val result1=arrint.map((x:Int)=>x*2)

   println(result1.mkString("|"))

   

     val result2=arrint.map((x)=>x*3)

   println(result2.mkString("|"))

   

     val result3=arrint.map(x=>x+2)

   println(result3.mkString("|"))

   

     val result4=arrint.map(_+1)

   println(result4.mkString("|"))

   

}

测试效果：

5.3高阶函数

高阶函数就是操作其他函数的函数。Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。

f:(Double)=>Double表示输入类型和返回类型都是Double类型

object section5_3 extends App {

  //新建一个高阶函数

  def higherOderFunction(f:(Double)=>Double)=f(100)

  def sqrt(x:Double)=Math.sqrt(x)

  val x=higherOderFunction(sqrt)

  println(s"x的值是$x")

  

  def higherOderFunction1(factor:Int):Double=>Double={

    println("返回新的函数")

    (x:Double)=>factor*x

  }

  val multiply=higherOderFunction1(100)

  val  y=multiply(10)

  println(s"y的值是$y")

  

  val a1=Array("Spark","Hive","Hadoop")

  val result=a1.map(_*2)              //相当于val result=a1.map((x:String)=>x*2)

  println(result.mkString("|"))

  

  val l=List("Spark"->1,"Hive"->2,"Hadoop"->3)

  println(l.map(x=>x._1))//取键名

  println(l.map(x=>x._2))//取键值

  

  println(l.map(_._1))//取键名

  println(l.map(_._2))//取键值

  

  val listInt=List(1,2,3)

  val r=listInt.flatMap(x=>x match{

    case 1=>List(1)

    case _=>List(x*2,x*3,x*4)

  }  )

  println(r)

  

  val arr1=Array(1,2,3,4,5)

  val r3=arr1.reduce((x:Int,y:Int)=>{

    println(x,y);

    x+y

  })

}

运行结果：

5.4 闭包

程序代码：

object section5_4 extends App {

  def a(f:Double=>Double,p:Double=>Unit):Double={

    val x=f(10)

    p(x)

    x

  }

  

  val f=(x:Double)=>x*2

  val p=(x:Double)=>println(x)

 

  val x=a(f,p)

  println(x)

}

运行结果：

5.5函数柯里化

注：柯里化函数多个参数用圆括号分隔，而高阶函数只用一个圆括号

程序代码：

object section5_5 extends App {

  def higherOderFunction(factor:Int)={

    (x:Double)=>factor*x

  }

  val a=higherOderFunction(10)

  println(a)

  

  

    val b=higherOderFunction(10)(50)   // val b=a(50)

  println(b)

  

  

  def multiply(factor:Int)(x:Double)=factor*x

  val c=multiply(10)(50)

  println(c)

  

  //

  

  val paf=multiply(10)_

  val d =paf(50)

  println(d)

}

5.6 部分应用函数

程序代码：

object p82 extends App {

  def product(x1:Int,x2:Int,x3:Int)=x1*x2*x3

  val a=product(1,2,3)

  println(a)

  

  //定义一个1参数的部分应用函数

  def product_1=product(_:Int,2,3)

 val b= product_1(2)

 println(b)

 

   //定义一个1参数的部分应用函数

  def product_2=product(_:Int,_:Int,3)

   val c= product_2(2,3)

 println(c)

 

def product_4=product _

val d= product_4(2,3,4)

 println(d)

}

运行结果：

5.7 偏函数

程序代码：

object p83 extends App {

  val sample=1 to 10

  val isEven: PartialFunction [Int,String]={

    case x if x %2==0=>x+"is even"

  }

  println(isEven)

  val a=isEven(10)

  println(a)

  

  

  val isOdd: PartialFunction[Int,String]={

    case x if x%2==1 =>x+" is odd"

  }

    println(isOdd)

 // val c=isOdd(10)

 // println(c)

  

   val d=isOdd(11)

  println(d)

}

运行结果：

大数据挖掘之Scala零基础学习（一）

猜你喜欢