Scala函数

一、声明函数

（一）显式声明函数

1、声明格式

[public | private | protected] def 函数名(参数列表) : 返回值声明 = {函数体}

2、 案例演示

（1）加法函数

创建net.hw.func包，在包里创建Example01对象

 

package net.hw.func

import scala.io.StdIn


object Example01 {
  def add1(a: Int, b: Int): Int = {
    return a + b
  }

  def add2(a: Int, b: Int): Int = {
    a + b
  }

  def add3(a: Int, b: Int) = {
    a + b
  }

  def add4(a: Int, b: Int) = a + b

  def add5(a: Int, b: Int) {
    println(a + " + " + b + " = " + (a + b))
  }

  def main(args: Array[String]): Unit = {
    print("a = ")
    val a = StdIn.readLine().toInt
    print("b = ")
    val b = StdIn.readLine().toInt

    println(a + " + " + b + " = " + add1(a, b))
    println(a + " + " + b + " = " + add2(a, b))
    println(a + " + " + b + " = " + add3(a, b))
    println(a + " + " + b + " = " + add4(a, b))
    add5(a, b)
  }
}

运行程序，查看结果

 

（2）阶乘函数

• 显式声明阶乘函数并调用
• 

 

（二）隐式声明函数

1、声明格式

(参数列表) => {函数体}

 

3、案例演示

（1）加法函数

• 在net.hw.func包里创建Example02对象
  

 

package net.hw.func

import scala.io.StdIn

object Example02 {
  val add1 = (a: Int, b: Int) => {a + b}
  val add2 = (a: Int, b: Int) => a + b
  val add3 = (n: Int) => n + 1

  def main(args: Array[String]): Unit = {
    print("a = ")
    val a = StdIn.readLine().toInt
    print("b = ")
    val b = StdIn.readLine().toInt

    println(a + " + " + b + " = " + add1(a, b))
    println(a + " + " + b + " = " + add2(a, b))
    println(a + " + " + 1 + " = " + add3(a))
  }
}

• 功能：将函数直接量(a: Int, b: Int) => {a + b}赋给常量add1。

• 运行程序，查看结果
  

   

  （2）三整数加法函数和阶乘函数

• 隐式声明三整数相加函数和阶乘函数
• 

 

（3）打印直角三角形

• 方法一、采用传统的双重循环实现
• 

 方法二、采用单重循环配上流间变量来实现

 方法三、采用映射算子(map())和遍历算子(foreach())来实现

 

（4）计算1 + 2 + 3 + …… + 100的值

• 不采用循环，而采用归约算子(reduce())算子来完成，归约算子传入一个匿名函数_ + _或(x, y) => x + y
• 

 

二、Scala函数种类

（一）成员方法

1、基本概念

• 函数被使用在类的内部，作为类的一个成员，称为类的成员方法。

2、案例演示

任务：显示文件中长度超过15的行

• 在项目根目录里创建文本文件test.txt
• 

 在net.hw.func包里创建Example03对象

package net.hw.func

import scala.io.Source

object Example03 {
  def filter(line: String, len: Int): Boolean = {
    line.length > len
  }

  def getLinesFromFile(path: String, len: Int) = {
    val lines = Source.fromFile(path).getLines()
    for (line <- lines if filter(line, len)) yield line
  }

  def main(args: Array[String]): Unit = {
    val lines = getLinesFromFile("test.txt", 15)
    for (line <- lines) println(line + " " + line.length)
  }
}

 运行程序，查看结果

（二）局部函数
1、基本概念

• 函数内嵌的函数称为局部函数，这样的函数，只能在外部函数内部使用，外界无法访问。注意，Java是不允许函数嵌套的，但是Scala是允许的。

• 2、案例演示

  任务：采用局部函数显示文件中长度超过15的行

• 在net.hw.func包里创建Example04对象
• 

package net.hw.func

import scala.io.Source

object Example04 {
  def getLinesFromFile(path: String, len: Int) = {
    def filter(line: String, len: Int): Boolean = {
      line.length > len
    }

    val lines = Source.fromFile(path).getLines()
    for (line <- lines if filter(line, len)) yield line
  }

  def main(args: Array[String]): Unit = {
    val lines = getLinesFromFile("test.txt", 15)
    for (line <- lines) println(line + " " + line.length)
  }
}

 运行程序，查看结果

 （三）匿名函数

1、基本概念

• 函数在Scala中是头等公民，这体现在函数可以任意赋值给变量或常量，甚至可当作方法的实参或当作方法的返回值。在Java中只有变量或常量才能这么去使用。将函数直接量赋值给一个常量或变量，得到就是一个函数值，在需要时可以通过这个函数值来调用方法本身。

2、案例演示
任务：将函数赋值给常量
在net.hw.func包里创建Example05对象

package net.hw.func

object Example05 {
  def sum(a: Int, b: Int): Int = a + b

  def main(args: Array[String]): Unit = {
    // 直接调用显式函数
    val r = sum(100, 150)
    println("r = " + r)

    // 将函数赋值给常量
    val sum1 = sum(_, _)
    val r1 = sum1(100, 150)
    println("r1 = " + r1)

    // 将函数固定一个参数后赋值给常量
    val sum2 = sum(_: Int, 100)
    val r2 = sum2(150)
    println("r2 = " + r2)

    // 将隐式函数赋值给常量
    val sum3 = (a: Int, b: Int) => a + b
    val r3 = sum3(100, 150)
    println("r3 = " + r3)
  }
}

 运行程序，查看结果

 

（四）高阶函数

1、基本概念

• 函数可以作为另一个函数的参数被传递或作为另一个函数的返回值。

2、案例演示

任务1、演示函数作为函数的参数

• 在net.hw.func包里创建Example06对象
  

package net.hw.func

object Example06 {
  def printStr: (String) => Unit = {
    x => println(x)
  }

  def main(args: Array[String]): Unit = {
    val cities = List("北京", "上海", "深圳", "泸州")
    cities.foreach(printStr)
  }
}

 

• 匿名函数x => println(x)作为函数printStr的返回值。
• 函数printStr作为列表对象cities的foreach方法的实参。

• 运行程序，查看结果
  

 

任务2、演示函数作为函数的返回值

• 在net.hw.func包里创建Example07对象
  

package net.hw.func


object Example07 {
  def findRecipe(name: String): (String) => (String) = {
    if (name == "鸡肉") {
      (food: String) => {
        println("把" + food + "切丁，放在锅里烧，出锅")
        "美味的宫保鸡丁"
      }
    } else if (name == "鸭子") {
      (food: String) => {
        println("把" + food + "洗干净，放在火上好，烤熟")
        "美味的北京烤鸭"
      }
    } else {
      (food: String) => {
        println("把" + food + "洗净，放在锅里烧，烧熟")
        "美味的食物"
      }
    }
  }

  def cook(food: String): String = {
    val recipe = findRecipe(food)
    recipe(food);
  }

  def main(args: Array[String]): Unit = {
    cook("鸡肉")
  }
}

 运行程序，查看结果

 

三、神奇占位符

（一）基本概念

（二）案例演示

任务1、演示过滤集合

• 在net.hw.func包里创建Example08对象
  

package net.hw.func


object Example08 {
  def main(args: Array[String]): Unit = {
    val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    println(list)

    println("奇数子列表：" + list.filter((num: Int) => {
      num % 2 == 1
    }))

    println("偶数子列表：" + list.filter(_ % 2 == 0))
  }
}

 运行程序，查看结果