Scala高阶函数与泛型

1. Scala中的函数

在Scala中，函数是“头等公民”，就和数字一样。可以在变量中存放函数，即：将函数作为变量的值（值函数）。

2. scala中的匿名函数，即没有函数名称的函数，匿名函数常作为高阶函数的参数使用

(x: Int) => x*3

　　=>使用场景小结：

　　a. 用于匿名函数中连接函数声明和函数体

　　b. 用于模式匹配中，连接case条件和表达式  case "+" => "This is a positive number"

　　c. 用于函数参数中，表示Call By Name的求值策略，函数实参每次在函数体内被用到时都会求值

3. scala中高阶函数分析

　　高阶函数：把函数作为参数的函数

def hFunc(f: (Double) => (Double)) = f(10)
//f：为一个参数为Double,返回值也是Double的函数，作为高阶函数hFunc的参数，可以简单将f理解为函数名称的占位符，定义一个具体函数后将其替换；　

　　scala> def half(x: Double):Double = x / 2
　　half: (x: Double)Double

　　scala> def hFunc(f: (Double) => (Double)) = f(10)
　　hFunc: (f: Double => Double)Double

　　scala> hFunc(half)
　　res19: Double = 5.0

　　//上述运行过程可看成 　　hFunc(half) = half(10)

4. 闭包：可理解为函数的嵌套

在一个函数定义中，包含另外一个函数的定义；并且在内函数中可以访问外函数中的变量。

5. 柯里化：

柯里化函数(Curried Function)是把具有多个参数的函数转换为一条函数链，每个节点上是单一参数。

6. scala中常用的高阶函数

scala> val numbers = List(1,2,3,4,5,6,7,8,9)
numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)　　　　　　
scala> numbers.map(_*2)
res20: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18)
 
scala> numbers.foreach(_*2)
 
scala> numbers
res22: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)　　　　*******由此结果可知，map操作返回一个新的list，foreach操作只有过程无返回值 
 
scala> numbers.filter(_%2==0)
res23: List[Int] = List(2, 4, 6, 8)
 
List(1,3,7).zip(List(2,4,6))
res30: List[(Int, Int)] = List((1,2), (3,4), (7,6))
 
scala> numbers.partition((i:Int) => i%3==0||i%3==1)
res29: (List[Int], List[Int]) = (List(1, 3, 4, 6, 7, 9),List(2, 5, 8))scala> List(1,3,7).zip(List(2,4,6))

res30: List[(Int, Int)] = List((1,2), (3,4), (7,6))
 
scala> numbers.find(_%3==0)
res31: Option[Int] = Some(3)
 
scala> val myList = List(List(1,5,7),List(3,2,6))
myList: List[List[Int]] = List(List(1, 5, 7), List(3, 2, 6))
 
scala> myList.flatten
res32: List[Int] = List(1, 5, 7, 3, 2, 6)　　

flatMap与map的区别比较明显，map针对单个元素进行操作，对于嵌套的集合类型操作完成后不会压平。

scala> val li = List(1,2,3)
li: List[Int] = List(1, 2, 3)
 
scala> val res = li.flatMap(x => x match {
     | case 3 => List('a','b')
     | case _ => List(x*2)
     | })
res: List[AnyVal] = List(2, 4, a, b)
 
scala>  li.map(x => x match {
     | case 3 => List('a','b')
     | case _ => x*2
     | })
res44: List[Any] = List(2, 4, List(a, b))

7. scala中的Option

Option[T]

在Scala里Option[T]实际上是一个容器，就像数组或是List一样，你可以把他看成是一个可能有零到一个元素的List。
当你的Option里面有东西的时候，这个List的长度是1（也就是 Some），而当你的Option里没有东西的时候，它的长度是0（也就是 None）

scala> val bag = List("1", "2", "three", "4", "one hundred seventy five")
bag: List[String] = List(1, 2, three, 4, one hundred seventy five)
 
scala> def toInt(in: String): Option[Int] = {
     |    try {
     |      Some(Integer.parseInt(in.trim))
     |    } catch {
     |      case e: Exception => None
     |    }
     |  }
toInt: (in: String)Option[Int]
 
scala> bag.map(toInt)
res46: List[Option[Int]] = List(Some(1), Some(2), None, Some(4), None)

8. scala中的泛型

　　a.泛型类

　　

　　b. 泛型函数　　

注意：这里的ClassTag是必须的，表示运行时的一些信息，比如类型。

scala>   import scala.reflect.ClassTag
import scala.reflect.ClassTag
 
scala>   def mkArray[T: ClassTag](elems:T*) = Array[T](elems:_*)
mkArray: [T](elems: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]
 
scala> mkArray(1,2,3,4,5)
res47: Array[Int] = Array(1, 2, 3, 4, 5)

　　c.Upper Bounds 与 Lower Bounds

　　类型的上界和下界，是用来定义类型变量的范围。它们的含义如下：

　　S <: T  这是类型上界的定义。也就是S必须是类型T的子类（或本身，自己也可以认为是自己的子类。

U >: T  这是类型下界的定义。也就是U必须是类型T的父类(或本身，自己也可以认为是自己的父类)。

* 演示类型变量的上界: S <: T
  * S和T代表类型
  * 含义是：S必须是T的子类或者本事，则T就叫S的上界
  */
 
//定义父类：Vehicle代表所有的交通工具
class Vehicle{
  //方法：驾驶
  def drive()  ={println("Driving")}
}
 
//定义Vehicle的两个子类：Car和Bicycle
class Car extends Vehicle{
  override def drive()  ={println("Car Driving")}
}
class Bicycle extends Vehicle{
  override def drive()  ={println("Bicycle Driving")}
}

//测试
object ScalaUpperBounds {
  //定义方法
  def takeVehicle[T <: Vehicle](v:T) = {v.drive()}
 
  def main(args: Array[String]) {
    //定义一个交通工具的对象
    var v:Vehicle = new Vehicle
    takeVehicle(v)
 
    var c:Car = new Car
    takeVehicle(c)
  }
}

　　d. 视图界定（View bounds）　

　　尽量使用视图界定，来取代泛型的上界，因为适用的范围更加广泛。视图界定<% 除了所有的子类型，还允许隐式转换过去的类型。

　　隐式转换是指采用implicit关键字修饰的类函数和属性，它在定义完成后由scala在后台自动运行，当遇到匹配的转换类型，scala会自动完成隐式转换。

　　

//Scala的隐式转换
 
//水果
class Fruit(name:String){
  def getFruitName():String = {name}
}
 
//猴子Monkey
class Monkey(f:Fruit){
  def say() = {println("Monkey like " + f.getFruitName())}
}
 
object ImplicitDemo {
  implicit  def fruitToMonkey(f:Fruit):Monkey = {new Monkey(f)}
 
  def main(args: Array[String]) {
    //创建一个Fruit的对象
    var f:Fruit = new Fruit("香蕉")
    //问题：能否调用f.say() 方法呢？解决方法：将Fruit的对象转换为Monkey的对象
    f.say()
  }
}

　　e：协变与逆变　　

　　协变：Scala的类或特征的范型定义中，如果在类型参数前面加入+符号，就可以使类或特征变为协变了。泛型变量的值可以是本身类型或者其子类的类型

　　逆变：在类或特征的定义中，在类型参数之前加上一个-符号，就可定义逆变范型类和特征了。泛型变量的值可以是本身类型或者其父类的类型

　　

//Scala的逆变：泛型变量的值可以是本身或者其父类
 
package demo2{
  //父类：动物
  class Animal{}
  //子类：鸟
  class Bird extends Animal
  //麻雀
  class Sparrow extends Bird
 
  //吃东西的类
  class EatSomething[-T](t:T){}
 
  object DemoClass2 {
    def main(args: Array[String]) {
      //创建一个Bird吃东西的对象
      var c1:EatSomething[Bird] = new EatSomething[Bird](new Bird)
 
      //创建一个麻雀吃东西的对象
      //问题：能否将c1付给c2？
      //原因：尽管Bird是Sparrow的父类，但是EatSomething[Bird]不是EatSomething[Sparrow]的父类
      var c2:EatSomething[Sparrow] = c1
    }
  }
}