1.函数
1.1函数的定义
scala中函数的定义如下代码:
scala> def fun1(name: String){println(name)}
fun1: (name: String)Unit
代码是定义了一个传入为String类型的参数name,并将name打印出来的函数。
其中def fun1(name: String){println(name)}中,def为定义函数用的标识符,fun1是函数名,name是函数参数,其类型为Sting类型,{ }内为函数的实现,println(name)表示打印参数name的值。因为没有定义函数的返回值,所以返回为Unit类型。
该函数的使用,代码如下:
scala> fun1("Spark")
Spark
1.2函数赋值给变量
scala作为函数式编程的语言。函数也是作为和变量一样的一等公民。所以函数可以赋值给变量。代码如下:
scala> val fun1_v = fun1 _
fun1_v: String => Unit
这里代码实现的是把前面定义的函数fun1赋值给不可变变量fun1_v。其中要注意的是val fun1_v = fun1 中的 fun1 下划线前面一定要有空格,这种写法是用到了scala语法中强大的类型推断。然后变量fun1_v就可以作为函数使用了。代码如下:
scala> fun1_v("Spark")
Spark
2.匿名函数
匿名函数:就是函数名可以匿名。也就是说在定义函数的时候可以不写函数名。可以看下面的代码例子,如下:
scala> val fun2 = (content: String) => println(content)
fun2: String => Unit
从代码中可以看出fun2是一个val的变量。后面是一个匿名函数的定义,这个匿名函数直接赋值给了fun2变量。其中content是匿名函数的参数,String是参数类型。=>后面是函数内容,表示打印传入参数content。
下面是对这个匿名函数的使用,代码如下:
scala> fun2("Hdaoop")
Hdaoop
3.高级函数
3.1函数的参数也可以是函数
3.1.1例子一
我们先定义一个匿名函数,并赋值给变量hiScala,如下:
scala> val hiScala = (content : String) => println(content)
hiScala: String => Unit
再定义一个参数为函数的函数,其中另一个参数为content。如下:
scala> def bigData(func: (String) => Unit,content: String) {func(content)}
bigData: (func: String => Unit, content: String)Unit
使用这个带参数为函数的函数,如下:
scala> bigData(hiScala,"Spark")
Spark
上面的第二段代码参数内的func: (String) => Unit 就是定义了一个函数作为参数,函数名为func,func函数带一个参数,这个参数为String类型(这里注意:这个参数为写明参数名称,只定义了参数类型。因为在scala中定义函数时候若只有一个参数,参数名是可以省略的)。函数的返回值为unit。
上面的第三段代码是调用这个函数bigData,传入的第一个参数为第一段代码定义的函数hiScala,第二个参数是一个字符串“Spark”。
3.1.2例子二
scala中的map也是高级函数,参数也可以是函数。例子如下:
先定义一个数组。
scala> val array = Array(1,2,3,4,5,6,7,8,9)
array: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
使用map函数,其中()里的是用一个函数作为参数,item是这个函数的传入参数,=>是函数的实现,对参数item扩大2倍,这里初看与例子一不同,改成array.map((item) => 2 * item),这样就可以和前面一样了,这里另加说明在scala中定义函数时候若只有一个参数,参数名是可以省略的,而且可以省略这个括号。
scala> array.map(item => 2 * item)
res5: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18)
用map来遍历打印数组值,代码如下:
scala> array.map(item => println(item))
1
2
3
4
5
6
7
8
9
res7: Array[Unit] = Array((), (), (), (), (), (), (), (), ())
3.2函数的返回值是个函数
先定义一个函数的返回值是个函数,如下:
scala> def func_Returned(content : String) = (message: String) =>println(message)
func_Returned: (content: String)String => Unit
使用这个函数func_Returned
scala> func_Returned("Spark")
res8: String => Unit
从结果中看出,输入时String,函数返回值unit,是一个函数function
为了更加方面看出调用过程,我们把content和message都打印出来。
scala> def func_Returned(content: String) = (message: String) => println(content + " "+message)
func_Returned: (content: String)String => Unit
重新调用,并赋值给变量returned
scala> val returned = func_Returned("Spark")
returned: String => Unit
调用returned
scala> returned("Scala")
Spark Scala
4.高级函数的类型推断
下面举例说明,如下:
4.1例子一
定义一个函数spark。
scala> def spark(func: (String) => Unit, name: String){func(name)}
spark: (func: String => Unit, name: String)Unit
调用函数spark
scala> spark((name: String) => println(name),"Scala")
Scala
当只有一个参数的时候可以省略返回值。
scala> spark((name) => println(name), "Scala")
Scala
也可以省略括号
scala> spark(name => println(name), "Scala")
Scala
当参数只被使用一次时候,还可以用_表示这个参数
scala> spark(println(_), "Scala")
Scala
还可以连下划线都木有
scala> spark(println, "Scala")
Scala
4.2例子二
scala> val array=Array(1,2,3,4,5,6,7,8,9)
array: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> array.map(2*_)
res0: Array[Int] = Array(2, 4, 6, 8, 10, 12, 14, 16, 18)
scala> array.map(2*_).foreach(println _)
2
4
6
8
10
12
14
16
18
scala> array.map(2*_).foreach(println)
2
4
6
8
10
12
14
16
18
scala> array.map(2*_).filter(_ > 10)foreach(println)
12
14
16
18
5.闭包
定义:函数的变量超出其有效作用域的时候,我们还能够对函数内部的变量进行访问。
scala> def scala(content : String) = (message : String) => println(content +" : "+message)
scala: (content: String)String => Unit
scala> val funcResult = scala("Spark")
funcResult: String => Unit
scala> funcResult("Flink")
Spark : Flink
从第二段代码看出传入参数是“Spark”给了content,这个content应该在第三段代码中超出作用域,所以
原理,scala为当前的函数生成了一个对象来维护这个变量,变量作为了这个类的成员变量,所以能一直被访问。
6.柯里化(curring)
柯里化(curring)是如果一个函数有多个参数,可以转换为多个函数,每个参数对于一个参数。例如一个函数带有二个参数,柯里化后可以转换为二个函数。见下面例子:
6.1 先举一个普通参数求和的函数例子
代码如下:
scala> def sum(x: Int,y: Int) = x+y
sum: (x: Int, y: Int)Int
scala> sum(1,2)
res0: Int = 3
用柯里化来实现参数和,定义两个函数,如下:
scala> def sum_Curring(x : Int) = (y: Int) => x+y
sum_Curring: (x: Int)Int => Int
下面用柯里化来调用,如下,一次调用二个函数。
scala> sum_Curring(1)(2)
res1: Int = 3
6.2 下面再看个更好的方式
定义如下
scala> def sum_Curring_Better(x : Int) = (y: Int) => x+y
sum_Curring_Better: (x: Int)Int => Int
定义还可以简化成这样,代码如下:
scala> def sum_Curring_Better(x : Int)(y: Int) = x+y
sum_Curring_Better: (x: Int)(y: Int)Int
调用过程如下:
scala> sum_Curring_Better(1)(3)
res2: Int = 4
7.高级函数reduceLeft()
直接看下面例子:
scala> (1 to 100).reduceLeft(_+_)
res0: Int = 5050
这个是求1到100求和的实现,reduceLeft(+)中的在刚开始时候,第一个下划线是做第一个参数,第二个下划线是做第二个参数,然后求和,所求的和再作为第一个参数,并对应第一个下划线,这时候的第二个下划线代表第三个参数。然后再用前面所求和来加上第三个参数,得到一个新的和再作为第一个参数,并对于第一个下划线,这时候的第二个下划线代表第四个参数。以此类推实现1到100求和。
8.集合的函数式编程
8.1 List
代码如下:
scala> val list = List("Scala","Spark","Fink")
list: List[String] = List(Scala, Spark, Fink)
scala> list.map("The content is : " + _)
res0: List[String] = List(The content is : Scala, The content is : Spark, The content is : Fink)
scala> list.map(println)
Scala
Spark
Fink
res1: List[Unit] = List((), (), ())
8.2 flatMap
代码如下:
scala> val cal = list.map("The content is : " + _)
cal: List[String] = List(The content is : Scala, The content is : Spark, The content is : Fink)
scala> cal
res3: List[String] = List(The content is : Scala, The content is : Spark, The content is : Fink)
scala> cal.flatMap(_.split(" "))
res4: List[String] = List(The, content, is, :, Scala, The, content, is, :, Spark, The, content, is, :, Fink)
scala> cal.flatMap(_.split(" ")).foreach(print)
Thecontentis:ScalaThecontentis:SparkThecontentis:Fink
8.3 zip
代码如下:
scala> list.zip(List(10,6,5))
res7: List[(String, Int)] = List((Scala,10), (Spark,6), (Fink,5))
XianMing
转载请注明出处