函数式编程

Scala 2的函数和类、对象一样，都是一等公民，函数可以脱离类和对象而独立存在。

但在Java里面，函数也就是方法，是不可能独立于类或对象独立存在的。

这是Scala 2和Java之间的一个显著的区别。

基本语法

函数式编程的核心就是将代码（或函数）赋值给一个变量，其语法格式为变量名 = 函数名 _。

package com.itechthink

/**
 * 将函数赋值给变量
 * 
 */
object Function01 {
	private def hello(name: String): Unit = {
		println("Hello, " + name)
	}

	def main(args: Array[String]): Unit = {
		// 将函数赋值给变量
		val sayHello = hello _
		sayHello("lixingyun")
	}
}

匿名函数

Scala 2中的函数也可以没有名字，这种函数叫匿名函数。

匿名函数的语法格式是(参数1: 数据类型, 参数2: 数据类型, ...) => 函数体。

这种形式和Java的Lambda表达式非常类似。

package com.itechthink

/**
 * 匿名函数
 *
 */
object Function02 {
	def main(args: Array[String]): Unit = {
		// 匿名函数
		val sayHello = (name: String) => {
			println("Hello, " + name)
		}

		sayHello("lixungyun")
	}
}

高阶函数

由于函数和类、对象一样，都是一等公民，所以也可以将函数直接作为另一个函数的参数传入其中。

所以，能够接收函数作为参数的函数，就称为高阶函数（higher-order function）。

package com.itechthink

/**
 * 高阶函数
 *
 */
object Function03 {
	// 先定一个匿名函数
	val sayHello = (name: String) => {
		println("'Hello, " + name + "'")
	}

	// 将匿名函数作为参数
	def greeting(host: String, guest: String, sayHello: (String) => Unit): Unit = {
		print(host + " said: ")
		sayHello(guest)
	}

	def main(args: Array[String]): Unit = {
		// 通过函数名调用
		greeting("lixingyun", "wanglin", sayHello)

		// 通过函数体调用
		greeting("lixingyun", "wanglin", (name: String) => {
			println("'Hello, " + name + "'")
		})

		// 当只有一个参数时，高阶函数可以自动推断出函数参数的类型，可以更进一步简化
		greeting("lixingyun", "wanglin", name => println("'Hello, " + name + "'"))
	}
}

常用函数

Scala 2中的很多常用高阶函数，都对应于大数据中的算子，例如map、flatMap、filter和foreach等。

package com.itechthink

import scala.io.Source._

/**
 * 常用高阶函数
 *
 */
object Function04 {
	def main(args: Array[String]): Unit = {
		// map
		println(Array(1, 2, 3, 4, 5).map(x => x * 2).mkString(","))
		// map的简写形式
		println(Array(1, 2, 3, 4, 5).map(_ * 2).mkString(","))

		// flatMap
		println(Array("hello scala", "hello world").flatMap(x => x.split(" ")).mkString("|"))
		// flatMap的简写形式
		println(Array("hello scala", "hello world").flatMap(_.split(" ")).mkString("|"))

		// foreach
		Array(1, 2, 3, 4, 5).foreach(x => println(x))
		// foreach的简写形式1
		Array(1, 2, 3, 4, 5).foreach(println(_))
		// foreach的简写形式2
		Array(1, 2, 3, 4, 5).foreach(println)
		Array(1, 2, 3, 4, 5).map(x => x * 2).foreach(x => println(x))

		// filter
		println(Array(1, 2, 3, 4, 5).filter(x => x % 2 == 0).mkString(","))
		// filter的简写形式
		println(Array(1, 2, 3, 4, 5).filter(_ % 2 == 0).mkString(","))

		// reduceLeft
		println(Array(1, 2, 3, 4, 5).reduceLeft((x, y) => x + y))
		// reduceLeft的简写形式
		println(Array(1, 2, 3, 4, 5).reduceLeft(_ + _))

		// 统计文件内的单词总数
		val lines = fromFile("/Users/bear/Downloads/scala.txt").mkString
		val words = List(lines, lines)
		// 均为简写
		println(
			words
				.flatMap(_.split(" "))
				// 将每个单词映射为(word, 1)的形式
				.map((_, 1))
				// 将(word, 1)映射为单独的1
				.map(_._2)
				// 对若干个1进行累加求和
				.reduceLeft(_ + _)
		)
	}
}

---

感谢支持

更多内容，请移步《超级个体》。