Scala函数式编程（笔记）

最新推荐文章于 2022-02-28 19:50:12 发布

杰森爱编程

最新推荐文章于 2022-02-28 19:50:12 发布

阅读量205

点赞数

本文链接：https://blog.csdn.net/Sunshinejourney/article/details/80164960

版权

http://www.runoob.com/scala/scala-closures.html 教程

函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法

方法的定义：

def add(x:Int,y:Int) = {x+y}

方法名add 参数列表返回Int类型

add: (x: Int, y: Int)Int

Unit代表没有返回值类型

def SayHi():Unit = {

println("Hello")

}

SayHi: ()Unit

默认返回值类型Unit空

scala> def SayHi { println("hello")}

SayHi: Unit

传入两个int 类型x,y 返回Int类型的结果

def main(arrgs:Array[String]){

print(fun(3,5))

}

//函数定义

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

return x + y

}

如果函数没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 实例如下：

也可写出如下返回unit无参数

def main(arrgs:Array[String]){

fun(3,5)

}

//函数定义

def fun(x:Int,y:Int):Unit = {

print(x+y)

}

比较大小

object Test{

def main(arrgs:Array[String]){

print(max(3,5))

}

//函数定义

def max(x:Int,y:Int):Int = if (x>y) x else y

//可写成：

def max(x:Int,y:Int) = if (x>y) x else y

}

可变参数函数

def main(args: Array[String]) {

delayed("spark","scala","hadoop")

}

def delayed(args:String* ) = {

for(arg<-args){

print(arg+" ")

}

//spark scala hadoop

递归函数：

def factorial(x:Int):Int = {

if(x == 1){

return 1

}

else{

return x * factorial(x-1)

}

函数传值,传入实现方法（高阶函数）

object Test{
def main(arrgs:Array[String]){

println(f1(3,3))

fun1((x:Int,y:Int)=>x*y)

}

//定义函数f1，传入两个int类型参数，返回double类型， { 实现体}

var f1:(Int,Int)=>Double = { (x:Int,y:Int)=>x*2*y }

//定义函数fun1,调用函数传入方法体

def fun1(a:(Int,Int)=>Double): Unit ={

print(a(3,4)) //函数定义

}
}

匿名函数：

//定义函数fun1,传入参数x,y 结果是x+y

def main(args: Array[String]) {

print(func1(3,4));

}

var func1 = (x:Int,y:Int)=>x+y;

偏应用函数

//函数info 调用两次：

def main(args: Array[String]) {

info("xiaowang",33);

info("zhangsan",30);

}

def info(name: String, age: Int) = {

println(name + "----" + age)

}

//改进成偏应用函数：定义函数newinfo传入的参数是info的参数

def main(args: Array[String]) {

var newinfo = info(_:String,_:Int);

newinfo("zhangsan",33)

}

def info(name: String, age: Int) = {

println(name + "----" + age)

}

偏应用函数：部分应用函数也是偏应用函数，把函数应用到参数上

scala> def funOption = (_:Int)+(_:String)

funOption: (Int, String) => String

scala> funOption(1,"Spark")

res4: String = 1Spark

柯里化函数curing

def main(args: Array[String]) {

println(info("wu")("xiang"));

println(info1("wu")("xiang"))

}

def info(x: String)(y: String) = {

x+y

}

//相当于：

def info1(x:String) = (y:String) => x+y

占位符代替参数：

scala> List(1,2,3,4).map((x:Int)=>x+2)

res0: List[Int] = List(3, 4, 5, 6)

scala> List(1,2,3,4).map(_+2)

res2: List[Int] = List(3, 4, 5, 6)

scala> List(1,2,3,4).map(_+2).foreach(println)

闭包和curring

闭包解析：

var factor = 3 val multiplier = (i:Int) => i * factor

Curring:

scala> def hiScala(human:String)=(human1:String)=> println(human1+" "+human)

scala> def funny(x:Int)(y:Int)(z:Int)=x+y+z

scala> funny(1)(2)(3)

res6: Int = 6

高阶函数

object Test{
  def main(args: Array[String]) {
     hello(hiScala,"welcome to Scala")
  }
  val hiScala = (name:String) => println(name)
  def hello(myFunction:(String)=>Unit,context: String): Unit ={   //把函数当作值传入方法
      myFunction(context)
  }
}

welcome to Scala

定义函数和方法三种写法

//定义函数
val f1 = (x:Int,y:Int) => x+y
//也可以写成：定义f1 参数函数体
val f1:(Int,Int)=>Int = {(x,y)=>x+y}
//方法的定义：
def add(x: Int, y: Int): Int = x + y

方法的定义和调用：（方法体不是函数体）

/**
  * Created by Wuxiang on 2017/6/25.
  */
object Test {
   def add(x:Int,y:Int): Int ={
     print(x + y)
   }
   def main(args: Array[String]) {
     add(3,5)
   }
}

函数f1 参数(x,y) 函数体 x+y

scala> val f1 = (x:Int,y:Int) => x+y

scala> f1(10,20)

定义函数f1：传入参数(Int,Int)=>传出参数Int = 函数体 {(x,y)=>x+y}

scala> val f1:(Int,Int)=>Int = {(x,y)=> x+y}

简写为 val f1 = (x:Int,y:Int) =>x+y

def main(args: Array[String]) {

println(f1(3,4))

}

val f1:(Int,Int)=>Int = (x,y)=>x+y

将Int转化为Double类型

scala> val f2:Int=>Double = {x=>x.toDouble}

简写为： val f2 = (x:Int)=>x.toDouble

object Test {
   def add(x:Int,y:Int): Int ={
     x + y
   }
   //内置函数定义
   val f2 = new Function2[Int,Int,Double] {
      def apply(v1:Int,v2:Int):Double = {
       (v1+v2).toDouble
     }
   }
   def main(args: Array[String]) {
      val ff = f2(3,4)
     println(ff)
   }
}

函数可以作为一个参数传入方法，函数就是算法（值传递）

Map是迭代每一个元素：

定义函数求平方：

scala> val f:Int=>Int = {x=>x*x}

scala> val arr = Array(1,2,3,4,5)

scala> arr.map(f)

def main(args: Array[String]) {

List(1,2,3,4).map(f).foreach(println)

}

val f:Int=>Int=x=>x*x

scala> arr.map((x:Int)=>x*x) x数组是Int类型，可以不用在定义

List(1,2,3,4).map(x=>x*x).foreach(println)

下划线代表传入的参数：

scala> arr.map(_*10)

　　　Array[Int] = Array(10, 20, 30, 40, 50)

过滤：

scala> arr.filter(x=>x%2!=0)

res31: Array[Int] = Array(1, 3, 5)

过滤条件，map重赋值函数，使得很简便：

arr.filter(m=>m%2==0).map(m=>m*100)　

//过滤出可mo 2的数字，2，4 然后重新赋值，平方，在循环打印

Array(1,2,3,4,5).filter(x=>x%2==0).map(x=>x*x).foreach(println)

object Test {
   def m2(f:(Int,Int)=>Double): Unit ={
     println(f(3,5));
   }
   def main(args: Array[String]) {
       m2((x:Int,y:Int)=>(x*y).toDouble);
   }
}