scala学习总结11（函数）

偏函数：

• 基本介绍：
  ①在对符合某个条件，而不是所有情况进行逻辑操作时，使用偏函数是一个不错的选择；
  ②将包在大括号内的一组case语句封装为函数，我们称之为偏函数，它只对会作用于指定类型的参数或指定范围值的参数实施计算，超出范围的值会忽略；
  ③偏函数在Scala中是一个特质PartialFunction

• 案例入门：
  给你一个集合val list = List(1, 2, 3, 4, “abc”) ，请完成如下要求:
  ①将集合list中的所有数字+1，并返回一个新的集合
  ②要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)

val list = (1,2,3,4,"zhc")
val addOne = new PartialFunction[Any,Int]{
  def isDdfinedAt(any: Any) = any.isInstanceOf[Int]
  def apply(any: Any) = any.asInstanceOf[Int]+1
}
val list1 = list.collect(addOne)
println(list1)

简化形式1：

def fun:PartialFunction[Any,Int] = {
  case i:Int => i+1//case语句可以自动转换为偏函数
}
val list = List(1,2,3,4,"zhy").collect(fun)

简化形式2：

val list =  List(1,2,3,4,"zhy").collect{case i:Int => i+1}

作为参数的函数

• 基本介绍：
  函数作为一个变量传入到了另一个函数中，那么该作为参数的函数的类型是：function1
• 示例：

def plus(i: Int) = i + 1
val arr = Array(1,2,3).map(plus(_))
println(arr.mkString(",")) 

匿名函数

• 基本介绍：
  没有名字的函数就是匿名函数，可以通过函数表达式来设置匿名函数
• 示例1：

val a = (x: Double) => 2 * x
println(a(2.1))

示例2：

val fun = (a: Int,b: Int) => {
  println("匿名函数被调用")
  a + b
}
println("fun类型是"+fun)//fun类型是<function2>
println(fun(1,2))

高阶函数

• 基本介绍：
  能够接受函数作为参数的函数就是高阶函数；

• 示例：

def test(f:Double => Double,n: Double) = {
  f(n)
}
def sum(d: Double):Double = {
  d+d
}
val res = test(sum,6.66)
println(res)

• 高阶函数可以返回函数类型（示例）：

def fun(a: Int) = {
  (b: Int) => a-b
}
val res = fun(1)(2)
println(res)

参数（类型）推断

• 基本介绍

  • 参数类型是可以推断时，可以省略参数类型；
  • 当传入的函数，只有单个参数时，可以省去括号；
  • 如果变量只在=>右边只出现一次，可以用_来代替；

• 示例：

val list = List(1,2,3,4)
list.map((a: Int)=> a + 1)
list.map(a => a +1 )
list.map(_ + 1)

list.reduce(_ + _) // 输出10

闭包

• 基本介绍：
  闭包就是一个函数和与其相关的引用环境组合的一个整体；
• 示例：

def fun(a :Int) = (b: Int) => a - b
val f = fun(20)//f就是闭包函数
println(f(1) + "," + f(2))//输出：19,18

函数柯里化

• 基本介绍：
  函数编程中，接受多个参数的函数可以转化为接受单个参数的函数，整个转化的过程就叫函数的柯里化

• 代码示例：

def fun(a: Int,b: Int) = a - b//常规方法
println(fun(2,1))

def fun1(a: Int) = (b: Int) => a - b//闭包
println(fun1(2)(1))

def fun2(a: Int)(b: Int) = a - b//函数柯里化
println(fun2(2)(1))

//比较两个字符串在忽略大小写的情况下是否相等
def fun3(s1: String)(s2: String):Boolean = s1.toLowerCase == s2.toLowerCase

抽象控制

• 基本介绍：
  参数是函数；
  函数参数没有输入值也没有返回值；
• 示例：

def fun(f:() => Unit)={
	new Thread{
		override def run():Unit ={
			f() //()k可以省略
		}
	}.start()
}

fun{
	() => println("hello~~~~~") //’() => ‘ 可以省略
	Thread.sleep(5000)
	println("hello")
}

递归相关

scala中循环不建议使用while和do…while,而建议使用递归。

• 示例1：

//求最大值
def getMax(list List[Int]){
  if(list.isEmpty)
    throw new java.util.noSuchElementException()
  if(list.size == 1)
    list.head
  else if(list.head > getMax(list.tail)) list.head 
  else getMax(list.tail)
}

• 示例2：

//翻转字符串
def reverse(s: String):String ={
  if(s.length == 1) s
  else reverse(s.tail) + s.head
}

• 示例3：

//求阶层
def factorial(n: Int): Long={
  if(n == 0) 1 else n * factorial(n-1)
}