Spark学习笔记3-Scala函数式编程

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
转载请注明出处