Scala-方法和函数

1、方法的定义
//def用来表示定义一个方法，m1表示方法名，(x:Int,y:Int)是参数列表（参数名：参数类型...）,Int = x + y中Int表示返回值类型，x + y则是方法体（当然也可以跟java一样使用{}包起来）
scala> def m1(x : Int, y : Int) : Int = x + y
m1: (x: Int, y: Int)Int
//调用函数
scala> val res = m1 (3,4)
res: Int = 7

函数值的返回类型也可以不用指定，会自动判断
//可以看到能自动判断返回值类型是Int，但是“=”还是要的
scala> def m1 (x : Int,y : Int) = x * y
m1: (x: Int, y: Int)Int

scala> val res1 = m1(3,4)
res1: Int = 12

定义无返回值类型的方法
如果方法体有多行语句，使用{}括起来
scala> def m1 (x : Int,y : Int) {
| print(x+y)
| }
m1: (x: Int, y: Int)Unit

scala> m1(5,6)
11
或者
scala> def m1 (x : Int,y : Int) :Unit = {
| println(x * y)
| }
m1: (x: Int, y: Int)Unit

scala> val res = m1(3,7)
21

上面都是返回单一值，也可以返回对偶元祖或者多个值
scala> def m1 (x : Int, y : Double) = (y,x)
m1: (x: Int, y: Double)(Double, Int)

scala> val res = m1(3,4.4)
res: (Double, Int) = (4.4,3)

2、函数的定义
//定义了匿名函数，没有"val 变量名="
scala> (x : Int, y : Int) => x * y
//res2表示变量名，使用它来调用函数，(Int,Int)则表示两个参数都是Int类型 Int = <function2>表示返回一个Int类型的值，函数体使用了两个参数
res2: (Int, Int) => Int = <function2>

scala> res2(3,4)
res3: Int = 12

//将匿名函数赋给变量f1（其实是不可变量value，但是还是称变量）
scala> val f1 = (x : Int, y : Int) => x + y
f1: (Int, Int) => Int = <function2>

scala> val res = f1(5,5)
res: Int = 10

scala> val f2 = (x: Int) => x * 10
f2: Int => Int = <function1>

scala> val res = f2 (7)
res: Int = 70

函数定义的另一种方式
//x表示传入的Int值，结果是x转String相当于val func = (x:Int) => x.toString
scala> val func: Int => String = {x => x.toString}
func: Int => String = <function1>

scala> val func2 = (x : Int) => x.toString
func2: Int => String = <function1>

scala> func(3)
res14: String = 3

scala> func2(3)
res15: String = 3
==============
scala> val func3 : (Int,Int) => Int = {(x,y) => x + y}
func3: (Int, Int) => Int = <function2>

scala> val func4 = (x :Int, y : Int) => x + y
func4: (Int, Int) => Int = <function2>

3、方法和函数的区别
在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作
案例：首先定义一个方法，再定义一个函数，然后将函数传递到方法里面
//定义m1方法，f : (Int, Int) => Int表示参数是个函数，该函数的参数列表有2个Int类型的形参，返回值是一个Int类型。该方法体中调用这个函数，所以返回类型自动判断也就是函数的返回类型。
scala> def m1 (f : (Int, Int) => Int) = {
| f(4,7)
| }
m1: (f: (Int, Int) => Int)Int

//定义要传入方法的函数
scala> val func = (x : Int, y : Int) => x * y
func: (Int, Int) => Int = <function2>

调用方法，传入函数
scala> val res = m1(func)
res: Int = 28

scala> val ran = 1.to(10)
ran: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> val f1 = (x : Int) => x * 2
f1: Int => Int = <function1>

scala> val result = ran.map(f1)
result: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

scala> val f2 = (x : Int) => x+10
f2: Int => Int = <function1>

scala> var result2 = ran.map(f2)
result2: scala.collection.immutable.IndexedSeq[Int] = Vector(11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

//直接传个匿名函数(x:Int) => x * 5
scala> ran.map((x:Int) => x * 5)
res9: scala.collection.immutable.IndexedSeq[Int] = Vector(5, 10, 15, 20, 25, 30, 35, 40, 45, 50)

//更简单的方式x => x * 5，x表示ran中的元素，x * 5表示对ran中的元素进行的操作，结果放入的新的集合中去。
scala> ran.map(x => x * 5)
res10: scala.collection.immutable.IndexedSeq[Int] = Vector(5, 10, 15, 20, 25, 30, 35, 40, 45, 50)

//最简单的方式“”表示ran中的元素
scala> ran.map( * 5)
res11: scala.collection.immutable.IndexedSeq[Int] = Vector(5, 10, 15, 20, 25, 30, 35, 40, 45, 50)

4、将方法转换为函数
使用神奇的下划线””
scala> def m1 (x: Int, y :Int) = x + y
m1: (x: Int, y: Int)Int
//使用 函数名 空格将m1这个方法转换成了函数
scala> val func1 = m1 _
func1: (Int, Int) => Int = <function2>

//调用由方法转换成的函数
scala> val result = func1(3,4)
result: Int = 7

//原来的方法并不改变
scala> m1(3,4)
res7: Int = 7

注
scala> val arr = Array (1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)

scala> var a1 = arr(1)
a1: Int = 2

scala> arr(1) = 100

scala> arr
res13: Array[Int] = Array(1, 100, 3, 4, 5)

注：val定义的不能修改指的是变量的引用不能改，但是数组内容可以修改。