Scala函数的定义，使用以及练习

Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。

Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。

Scala 中使用 val 语句可以定义函数，def 语句定义方法

一.方法

1.方法声明

如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型

def functionName ([参数列表]):[return type]

2.方法定义

def functionName([参数列表]):[return type]={
   
    function body
    return [expr]
}

示例

//有返回值
def add(a:Int,b:Int):Int={
   
    var sum:Int=0
    sum=a+b
    return sum
}
//无返回值
def printMe( ) : Unit = {
   
      println("Hello, Scala!")
   }

3.方法调用

functionName(参数列表)
//如果方法使用了实例的对象来调用，我们可以使用类似java的格式 (使用 . 号)：
[instance.]functionName( 参数列表 )

二.java Lambda表达式

函数式接口

• 一种只含有一个抽象方法声明的接口
• 可以使用匿名内部类类实例化函数式接口的对象
• 通过lambda表达式可以进一步简化代码

lambda语法

(parameters)->expression
(parameters)_>{statements;...}

内置四大函数式接口

• 消费接口：Consumer
• 供给型接口：Supplier
• 断言型接口：Predicate
• 函数型接口：Function<T,R>

示例

Consumer<String> consumer=(s)-> System.out.println(s.toUpperCase());
consumer.accept("testabc");
list.foreach(x-> System.out.println(x);)
Supplier <Double>  supplier = () -> Math.random();
System.out.println(supplier.get());
Predicate<String> condition=s -> s.length()>4;
if(condition.test("hello")) System.out.println("true");
Function<String,String> toUpper=(s)->s.toUpperCase();
System.out.println(toUpper.apply("test"));

三.Scala方法和函数

1.函数定义

• 函数式编程：函数是Scala的核心
• 方法是类的一部分，属于定义在类中的函数
• 函数定义:

//定义函数方式一
def 函数名([参数列表])[:返回类型]={
    //返回类型为Unit的函数，称为过程（可省略=）
    函数体
     [return] 表达式
}
//匿名函数定义
(参数列表)=>{
   函数体}
val f1=(x:Int,y:Int)=>x+y
123456

2.函数调用

• 函数调用:函数名(参数列表)

（1）传值调用（call-by-value）

传值调用时，参数只在调用时计算一次，后续重复使用计算的结果

def square(x: Int): Int = {
    
    println(x)    //3
    x * x             //计算3*3
}
square(1+2)   //先计算1+2

（2）传名调用（call-by-name）

传名调用时，参数在调用时不会计算，只有真正用到参数时才计算

def square(x: => Int): Int = {
    
    println(x)    //计算1+2
    x * x             //计算(1+2)*(1+2)
}
square(1+2)   //调用时不计算

3.命名函数

• 通常情况下，传入参数与函数定义的参数列表一一对应
• 命名参数允许使用任意顺序传入参数

def printName(first:String, last:String) = {
   
    println(first + " " + last)
}
 
//Prints "John Smith"
printName("John","Smith")
printName(first = "John",last = "Smith")
printName(last = "Smith",first = "John") //任意顺序

4.参数缺省值（即默认值）

• Scala函数允许指定参数的缺省值，从而允许在调用函数时不指明该参数

def printName(first:String="John", last:String="Smith") = {
   
    println(first + " " + last)
}
//Prints "John Smith"
printName()
printName("zhang")
printName("zhang","san")
//输出
John Smith
zhang Smith
zhang san

5.匿名函数

（参数列表）=>{函数体}

• 指不含函数名称的函数
• 匿名函数定义
  “=>”左边为参数列表
  “=>”右边为函数体
  如果函数体包括多条语句，应使用“{}”包含

val f1=(x:Int)=>{
   println(x);x*x}//将匿名函数赋值给变量f1
println(f1(2))
//输出
2
4

6.高阶函数

• 高阶函数可以将其他函数作为参数或者使用函数作为输出结果
  常用高阶函数
  map
  foreach
  filter
  fold、foldLeft、foldRight
  reduce
  zip
  flatten
  flatMap

（1） 函数作为参数

    //定义一个普通函数
    def square(x:Int)=x*x
    val f0=(x:Int)=>x*x
   //定义一个高阶函数
    def dosquare(f:Int=>Int,p:Int):Int=f(p)
    println(dosquare(square,2))
    println(dosquare(f0, 8))
   //输出
   4
   64

（2）函数作为返回值

   //将函数作为返回值
    def dosquare2()={
   (x:Int)=>x*x}
    //调用函数
    println(dosquare2()(2))
   //输出
   4

• 常用高阶函数
  map：集合里的所有元素都进行一样的操作
  foreach：进行打印遍历
  filter：过滤
  fold、foldLeft、foldRight：折叠计算
  reduce：归约操作
  zip：拉链
  flatten：扁平化处理
  flatMap：先flatten再Map

//定义集合List为l
scala> val l=List(1,2,3,4,5,6,7,8,9)
l: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)
//map
scala> l.map(x=>x