Scala函数式编程

目录

一、Scala函数式编程

多范式：面向对象，函数式编程（程序实现起来简单）

举例：WordCount
sc 是 SparkContext , 非常重要

一行：

 
 

  
  var result = sc.textFile(
  
  "hdfs://xxxx/xxx/data.txt")

 
 
 
 

  
  .flatMap(
  
  _.
  
  split(
  
  " ")).
  
  map((
  
  _,
  
  1)).reduceByKey(
  
  _+
  
  _).collect

 
 

1、复习函数

关键字 def

2、匿名函数

没有名字的函数
举例：

 
 

  
  scala> 
  
  var myarray = 
  
  Array(
  
  1,
  
  2,
  
  3)

 
 
 
 

  
  myarray: 
  
  Array[
  
  Int] = 
  
  Array(
  
  1, 
  
  2, 
  
  3)

 
 
 
 

  
  

 
 
 
 

  
  scala> def fun1(x:
  
  Int):
  
  Int = x*
  
  3

 
 
 
 

  
  fun1: (x: 
  
  Int)
  
  Int

 
 
 
 

  
  

 
 
 
 

  
  scala> (x:
  
  Int) => x*
  
  3

 
 
 
 

  
  res0: 
  
  Int => 
  
  Int = <function1>

 
 
 
 

  
  

 
 
 
 

  
  问题：怎么去调用？高阶函数

 
 
 
 

  
  scala> fun1(
  
  3)

 
 
 
 

  
  res1: 
  
  Int = 
  
  9

 
 
 
 

  
  

 
 
 
 

  
  scala> myarray.
  
  foreach(println)

 
 
 
 

  
  1

 
 
 
 

  
  2

 
 
 
 

  
  3

 
 
 
 

  
  

 
 
 
 

  
  //调用匿名函数

 
 
 
 

  
  scala> myarray.map((x:
  
  Int) => x*
  
  3)

 
 
 
 

  
  res3: 
  
  Array[
  
  Int] = 
  
  Array(
  
  3, 
  
  6, 
  
  9)

 
 
 
 

  
  

 
 
 
 

  
  (_,
  
  1)  (_+_) 都是匿名函数

 
 

3、高阶函数（带有函数参数的函数）

把一个函数作为另外一个函数的参数值

定义一个高阶函数：
对10做某种运算

 
 

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

 
 
 
 

  
  someAction: (f: 
  
  Double => 
  
  Double)
  
  Double

 
 

解释：
(Double)=>(Double) 代表了f 的类型：入参是double，返回值也是double的函数

 
 

  
  import scala.math._

 
 
 
 

  
  

 
 
 
 

  
  scala> someAction(
  
  sqrt)

 
 
 
 

  
  res5: 
  
  Double = 
  
  3.1622776601683795

 
 
 
 

  
  

 
 
 
 

  
  scala> someAction(
  
  sin)

 
 
 
 

  
  res6: 
  
  Double = -
  
  0.5440211108893698

 
 
 
 

  
  

 
 
 
 

  
  scala> someAction(
  
  cos)

 
 
 
 

  
  res7: 
  
  Double = -
  
  0.8390715290764524

 
 
 
 

  
  

 
 
 
 

  
  scala> someAction(println)

 
 
 
 

  
  <console>:
  
  16: error: 
  
  type mismatch;

 
 
 
 

  
  found   : () => 
  
  Unit

 
 
 
 

  
  required: 
  
  Double => 
  
  Double

 
 
 
 

  
     someAction(println)

 
 
 
 

  
                  ^

 
 
 
 

  
  def someAction(f:(
  
  Double)=>(
  
  Double)) = f(
  
  10)

 
 
 
 

  
  

 
 
 
 

  
  someAction(
  
  sqrt) = 
  
  sqrt(
  
  10)

 
 

4、高阶函数的实例

scala中提供了常用的高阶函数

（1）map : 相当于一个循环，对某个集合中的每个元素都进行操作（接收一个函数），返回一个新的集合

scala> var numbers = List(1,2,3,4,5,6,7,8,9,10)
numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> numbers.map((i:Int)=>i*2)
res2: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

scala> numers.map(_*2)
res3: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

说明：
(i:Int)=>i*2 与 _*2 等价的

 
 

  
  (
  
  i
  
  :Int,j
  
  :Int)=>i+j   _+_

 
 

scala> numbers
res4: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
不改变numbers本身的值

（2）foreach：相当于一个循环，对某个集合中的每个元素都进行操作（接收一个函数），不返回结果
scala> numbers.foreach(println)
1
2
3
4
5
6
7
8
9
10

numbers.foreach(_*2)
没有返回值

（3） filter ：过滤，选择满足的数据
举例：查询能被2整除的数字

scala> numbers.filter((i:Int)=>i%2==0)
res5: List[Int] = List(2, 4, 6, 8, 10)

filter函数，参数要求：要求一个返回 bool 值的函数，筛选出所有为true的数据

（4）zip操作：合并两个集合
scala> List(1,2,3).zip(List(4,5,6))
res6: List[(Int, Int)] = List((1,4), (2,5), (3,6))

//少的话匹配不上就不合并
scala> List(1,2,3).zip(List(4,5))
res7: List[(Int, Int)] = List((1,4), (2,5))

scala> List(1).zip(List(4,5))
res8: List[(Int, Int)] = List((1,4))

（5）partition ： 根据断言（就是某个条件，匿名函数）的结果，来进行分区
举例：
能被2整除的分成一个区，不能被2整除的分成另外一个区
scala> numbers.partition((i:Int)=>i%2==0)
res9: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))

（6）find ： 查找第一个满足条件的元素
scala> numbers.find(_%3==0)
res10: Option[Int] = Some(3)

_%3==0 (i:Int)=>i%3==0 一样

（7）flatten：把嵌套的结果展开
scala> List(List(2,4,6,8,10),List(1,3,5,7,9)).flatten
res11: List[Int] = List(2, 4, 6, 8, 10, 1, 3, 5, 7, 9)

（8）flatmap : 相当于一个 map + flatten
scala> var myList = List(List(2,4,6,8,10),List(1,3,5,7,9))
myList: List[List[Int]] = List(List(2, 4, 6, 8, 10), List(1, 3, 5, 7, 9))

scala> myList.flatMap(x=>x.map(_*2))
res22: List[Int] = List(4, 8, 12, 16, 20, 2, 6, 10, 14, 18)

myList.flatMap(x=>x.map(_*2))

执行过程：
1、将 List(2, 4, 6, 8, 10), List(1, 3, 5, 7, 9) 调用 map(_*2) 方法。x 代表一个List
2、flatten

 
 

  
  package day4

 
 
 
 

  
  

 
 
 
 

  
  /**

 
 
 
 

  
    * 对比flatmap与map

 
 
 
 

  
    */

 
 
 
 

  
  object Demo2 {

 
 
 
 

  
  

 
 
 
 
  
  
  /**

 
 
 
 

  
      * flatmap执行分析

 
 
 
 

  
      * 1 List(1*2)   List(2)

 
 
 
 

  
      * 2 List(2*2)   List(4)

 
 
 
 

  
      * 3 List('a','b')

 
 
 
 

  
      *

 
 
 
 

  
      * List(List(2),List(4),List('a','b')).flatten

 
 
 
 

  
      * List(2,4,'a','b')

 
 
 
 

  
      */

 
 
 
 

  
    def flatMap(){

 
 
 
 

  
      val li = 
  
  List(
  
  1,
  
  2,
  
  3)

 
 
 
 

  
      val res = li.flatMap(x=>

 
 
 
 

  
        x match{

 
 
 
 
      
  
  case 
  
  3=>
  
  List(
  
  'a',
  
  'b')

 
 
 
 
      
  
  case _=>
  
  List(x*
  
  2)

 
 
 
 

  
      })

 
 
 
 

  
      println(res)

 
 
 
 

  
    }

 
 
 
 

  
  

 
 
 
 
  
  
  /**

 
 
 
 

  
      * map过程解析

 
 
 
 

  
      * 

 
 
 
 

  
      * 1 2  ---->List(2,2,3)

 
 
 
 

  
      * 2 4  ---->List(2,4,5)

 
 
 
 

  
      * 3 List('a','b')---->List(2,4,List('a','b'))

 
 
 
 

  
      */

 
 
 
 

  
    def map(){

 
 
 
 

  
      val li = 
  
  List(
  
  1,
  
  2,
  
  3)

 
 
 
 

  
      val res = li.map(x=>

 
 
 
 

  
        x match{

 
 
 
 
      
  
  case 
  
  3=>
  
  List(
  
  'a',
  
  'b')

 
 
 
 
      
  
  case _=>x*
  
  2

 
 
 
 

  
      })

 
 
 
 

  
      println(res)

 
 
 
 

  
    }

 
 
 
 

  
  

 
 
 
 

  
    def main(args: Array[
  
  String]): Unit = {

 
 
 
 

  
      flatMap()

 
 
 
 

  
      map()

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

5、概念：闭包、柯里化

（1）闭包：就是函数的嵌套
在一个函数的里面，包含了另一个函数的定义
可以在内函数中访问外函数的变量

举例：

 
 

  
  def mulBy(factor:Double) = 
  
  (x:Double)=>x*factor

 
 
 
 

  
          外                           内

 
 

乘以三：

 
 

  
  scala> def mulBy(factor:
  
  Double) = (x:
  
  Double)=>x*factor

 
 
 
 

  
  mulBy: (factor: 
  
  Double)
  
  Double => 
  
  Double

 
 
 
 

  
  

 
 
 
 

  
  scala> 
  
  var triple = mulBy(
  
  3)

 
 
 
 

  
  triple: 
  
  Double => 
  
  Double = <function1>

 
 
 
 

  
  

 
 
 
 

  
  相当于 triple(x:
  
  Double) = x*
  
  3

 
 
 
 

  
  

 
 
 
 

  
  scala> triple(
  
  10)

 
 
 
 

  
  res1: 
  
  Double = 
  
  30.0

 
 
 
 

  
  

 
 
 
 

  
  scala> triple(
  
  20)

 
 
 
 

  
  res2: 
  
  Double = 
  
  60.0

 
 
 
 

  
  

 
 
 
 

  
  scala> 
  
  var half = mulBy(
  
  0.5)

 
 
 
 

  
  half: 
  
  Double => 
  
  Double = <function1>

 
 
 
 

  
  

 
 
 
 

  
  scala> half(
  
  10)

 
 
 
 

  
  res3: 
  
  Double = 
  
  5.0

 
 

引入柯里化：
scala> mulBy(3)(10)
res4: Double = 30.0

（2）柯里化
概念：柯里化函数：是把具有多个参数的函数，转化为一个函数链，每个节点上都是单一函数

def add(x:Int,y:Int) = x+y

def add(x:Int)(y:Int) = x+y

转化步骤：

原始：def add(x:Int,y:Int) = x+y

闭包：def add(x:Int) = (y:Int) => x+y

简写：def add(x:Int)(y:Int) = x+y

scala> def add(x:Int)(y:Int) = x+y
add: (x: Int)(y: Int)Int

scala> add(1)(2)
res5: Int = 3

二、Scala集合

1、可变集合和不可变集合（Map）

immutable mutable
举例：
scala> def math = scala.collection.immutable.Map(“Tom”->80,”Lily”->20)
math: scala.collection.immutable.Map[String,Int]

scala> def math = scala.collection.mutable.Map(“Tom”->80,”Lily”->20,”Mike”->95)
math: scala.collection.mutable.Map[String,Int]

集合的操作：
获取集合中的值
scala> math.get(“Tom”)
res1: Option[Int] = Some(80)

scala> math(“Tom”)
res2: Int = 80

scala> math(“Tom123”)
java.util.NoSuchElementException: key not found: Tom123
at scala.collection.MapLike$class.default(MapLike.scala:228)
at scala.collection.AbstractMap.default(Map.scala:59)
at scala.collection.mutable.HashMap.apply(HashMap.scala:65)
… 32 elided

scala> math.get(“Tom123”)
res3: Option[Int] = None

scala> math.contains(“Tom123”)
res4: Boolean = false

scala> math.getOrElse(“Tom123”,-1)
res5: Int = -1

更新集合中的值：注意：必须是可变集合
scala> math
res6: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)

scala> math(“Tom”)=0
scala> math
res7: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)

造成上述现象的原因，没有import包，如果import以后，问题解决：
scala> import scala.collection.mutable._
import scala.collection.mutable._

scala> var math = Map(“Tom”->80,”Lily”->20,”Mike”->95)
math: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)

scala> math(“Tom”)=0
scala> math
res8: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 0, Lily -> 20)

添加新的元素
scala> math(“Tom”)=80
scala> math += “Bob”->85
res9: scala.collection.mutable.Map[String,Int] = Map(Bob -> 85, Mike -> 95, Tom -> 80, Lily -> 20)

移出一个元素
scala> math -= “Bob”
res10: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)

2、列表：可变列表，不可变列表

不可变列表 List
scala> var myList=List(1,2,3)
myList: List[Int] = List(1, 2, 3)

scala> val nullList:List[Nothing] = List()
nullList: List[Nothing] = List()

//二维列表
scala> val dim : List[List[Int]] = List(List(1,2,3),List(4,5,6))
dim: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6))

scala> myList.head
res11: Int = 1

scala> myList.tail
res12: List[Int] = List(2, 3)

注意：tail 是除了第一个元素外，其他的元素

可变列表：LinedList 在 scala.collection.mutable 包中

scala> var myList = scala.collection.mutable.LinkedList(1,2,3,4)
warning: there was one deprecation warning; re-run with -deprecation for details
myList: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

需求：把上面列表中，每一个元素都乘以2

游标，指向列表的开始

 
 

  
  var cur = myList

 
 
 
 

  
  //Nil意思为空

 
 
 
 

  
  while(cur != Nil ){

 
 
 
 

  
  

 
 
 
 
    
  
  //把当前元素乘以2

 
 
 
 

  
      cur
  
  .elem = cur.elem*
  
  2

 
 
 
 

  
  

 
 
 
 
    
  
  //移动指针到下一个元素

 
 
 
 

  
      cur = cur
  
  .next

 
 
 
 

  
  }

 
 

scala> var cur = myList
cur: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)

scala> while(cur != Nil ){
| cur.elem = cur.elem*2
| cur = cur.next
| }

scala> myList
res13: scala.collection.mutable.LinkedList[Int] = LinkedList(2, 4, 6, 8)

scala> myList.map(_*2)
warning: there was one deprecation warning; re-run with -deprecation for details
res14: scala.collection.mutable.LinkedList[Int] = LinkedList(4, 8, 12, 16)

3、序列

（*）数据库中也有序列：sequence 、 auto increment
（1）作为主键，实现自动增长
（2）提高性能，序列在Oracle是在内存中的

（*）Vector Range
举例：
Vector 是一个带下标的序列，我们可以通过下标来访问Vector中的元素
scala> var v = Vector(1,2,3,4,5,6)
v: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 6)

Range ： 是一个整数的序列
scala> Range(0,5)
res15: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4)

从0开始，到5 ，但不包括5

scala> println(0 until 5)
Range(0, 1, 2, 3, 4)

scala> println(0 to 5)
Range(0, 1, 2, 3, 4, 5)

Range可以相加
scala> (‘0’ to ‘9’) ++ (‘A’ to ‘Z’)
res16: scala.collection.immutable.IndexedSeq[Char] = Vector(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

把Range转换成list
scala> 1 to 5 toList
warning: there was one feature warning; re-run with -feature for details
res17: List[Int] = List(1, 2, 3, 4, 5)

4、集（Set）

不重复元素的集合，默认是HashSet，与java类似
scala> var s1 = Set(1,2,10,8)
s1: scala.collection.immutable.Set[Int] = Set(1, 2, 10, 8)

scala> s1 + 10
res18: scala.collection.immutable.Set[Int] = Set(1, 2, 10, 8)

scala> s1 + 7
res19: scala.collection.immutable.Set[Int] = Set(10, 1, 2, 7, 8)

scala> s1
res20: scala.collection.immutable.Set[Int] = Set(1, 2, 10, 8)

创建一个可排序的Set SortedSet
scala> var s2 = scala.collection.mutable.SortedSet(1,2,3,10,8)
s2: scala.collection.mutable.SortedSet[Int] = TreeSet(1, 2, 3, 8, 10)

判断元素是否存在
scala> s2.contains(1)
res21: Boolean = true

scala> s2.contains(1231231)
res22: Boolean = false

集的运算：union并集 intersect 交集 diff 差集
scala> var s1 = Set(1,2,3,4,5,6)
s1: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

scala> var s2 = Set(5,6,7,8,9,10)
s2: scala.collection.immutable.Set[Int] = Set(5, 10, 6, 9, 7, 8)

scala> s1 union s2
res23: scala.collection.immutable.Set[Int] = Set(5, 10, 1, 6, 9, 2, 7, 3, 8, 4)

scala> s1 intersect s2
res24: scala.collection.immutable.Set[Int] = Set(5, 6)

scala> s1 diff s2
res25: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)

数据库里面的union操作，要求：
列数一样
列的类型一样

 
 

  
  select A,B from ****

 
 
 
 

  
  union 

 
 
 
 

  
  select C,D from *****

 
 

函数的定义+返回值
def sum():Int =

python数据分析
pyspark

5、模式匹配

相当于java中的switch case语句 但是 功能更强大

 
 

  
  package day5

 
 
 
 

  
  

 
 
 
 

  
  /**

 
 
 
 

  
    * 模式匹配

 
 
 
 

  
    */

 
 
 
 

  
  object Demo1 {

 
 
 
 

  
    def main(args: 
  
  Array[String]): Unit = {

 
 
 
 
    
  
  //1、相当于java switch case

 
 
 
 
    
  
  var chi = 
  
  '-'

 
 
 
 
    
  
  var sign = 
  
  0

 
 
 
 

  
  

 
 
 
 

  
      chi match {

 
 
 
 
      
  
  case 
  
  '+' => sign = 
  
  1

 
 
 
 
      
  
  case 
  
  '-' => sign = 
  
  -1

 
 
 
 
      
  
  case _ => sign = 
  
  0

 
 
 
 

  
      }

 
 
 
 

  
      println(sign)

 
 
 
 

  
  

 
 
 
 
    
  
  /**

 
 
 
 

  
        * 2、scala中的守卫，case _ if 匹配某种类型的所有值

 
 
 
 

  
        * 需求：匹配所有的数字

 
 
 
 

  
        */

 
 
 
 
    
  
  var ch2 = 
  
  '5'

 
 
 
 
    
  
  var result : 
  
  Int = 
  
  -1

 
 
 
 

  
      ch2 match {

 
 
 
 
      
  
  case 
  
  '+' => println(
  
  "这是一个加号")

 
 
 
 
      
  
  case 
  
  '-' => println(
  
  "这是一个减号")

 
 
 
 
      
  
  //这里的10表示转换成1十进制

 
 
 
 
      
  
  case _ 
  
  if Character.isDigit(ch2) => result=Character.digit(ch2,
  
  10)

 
 
 
 
      
  
  case _ => println(
  
  "其他")

 
 
 
 

  
      }

 
 
 
 

  
      println(result)

 
 
 
 

  
  

 
 
 
 
    
  
  /**

 
 
 
 

  
        * 3、在模式匹配中使用变量

 
 
 
 

  
        * 如果改成var mystr = "Hello W+rld"

 
 
 
 

  
        * 打印：加号

 
 
 
 

  
        *

 
 
 
 

  
        * 匹配中，则相当于break

 
 
 
 

  
        */

 
 
 
 
    
  
  var mystr = 
  
  "Hello World"

 
 
 
 
    
  
  //取出某个字符，赋给模式匹配的变量

 
 
 
 

  
  

 
 
 
 

  
      mystr(
  
  7) match {

 
 
 
 
      
  
  case 
  
  '+' => println(
  
  "加号")

 
 
 
 
      
  
  case 
  
  '-' => println(
  
  "减号")

 
 
 
 
      
  
  //case 语句中使用变量 ch代表传递进来的字符

 
 
 
 
      
  
  case ch => println(ch)

 
 
 
 

  
      }

 
 
 
 

  
  

 
 
 
 
    
  
  /**

 
 
 
 

  
        * 4、匹配类型 instance of

 
 
 
 

  
        * 用法：case x : Int =>

 
 
 
 

  
        *

 
 
 
 

  
        * Any : 表示任何类型，相当于java中的Object

 
 
 
 

  
        * Unit : 表示没有值， void

 
 
 
 

  
        * Nothing : 表示在函数抛出异常时，返回值就是Nothing

 
 
 
 

  
        *           是scala类层级中的最低端，是任何其他类型的子类型

 
 
 
 

  
        * Null : 表示引用类型的子类，值：null

 
 
 
 

  
        *

 
 
 
 

  
        * 特殊类型

 
 
 
 

  
        * Option : 表示一个值是可选的（有值或者无值）

 
 
 
 

  
        * Some : 如果值存在，Option[T] 就是一个Some[T]

 
 
 
 

  
        * None : 如果值不存在，Option[T] 就是一个None

 
 
 
 

  
        *

 
 
 
 

  
        * scala> var myMap = Map("Time"->96)

 
 
 
 

  
        * myMap: scala.collection.immutable.Map[String,Int] = Map(Time -> 96)

 
 
 
 

  
        *

 
 
 
 

  
        * scala> myMap.get("Time")

 
 
 
 

  
        * res0: Option[Int] = Some(96)

 
 
 
 

  
        *

 
 
 
 

  
        * scala> myMap.get("Time12342")

 
 
 
 

  
        * res1: Option[Int] = None

 
 
 
 

  
        *

 
 
 
 

  
        * Nil : 空的List

 
 
 
 

  
        *

 
 
 
 

  
        * 四个N总结：None Nothing Null Nil

 
 
 
 

  
        * None : 如果值不存在，Option[T] 就是一个None

 
 
 
 

  
        * Nothing : 如果方法抛出异常时，则异常的返回值类型就是Nothing

 
 
 
 

  
        * Null : 可以赋值给所以的引用类型，但是不能赋值给值类型

 
 
 
 

  
        *       class Student

 
 
 
 

  
        *       var s1 = new Student

 
 
 
 

  
        *       s1 = null

 
 
 
 

  
        * Nil : 空的List

 
 
 
 

  
        */

 
 
 
 
    
  
  var v4 : Any = 
  
  100

 
 
 
 

  
      v4 match {

 
 
 
 
      
  
  case x : 
  
  Int => println(
  
  "这是一个整数")

 
 
 
 
      
  
  case s : String => println(
  
  "这是一个字符串")

 
 
 
 
      
  
  case _ => println(
  
  "这是其他类型")

 
 
 
 

  
      }

 
 
 
 

  
  

 
 
 
 
    
  
  //5、匹配数组和列表

 
 
 
 
    
  
  var myArray = 
  
  Array(
  
  1,
  
  2,
  
  3)

 
 
 
 

  
      myArray match {

 
 
 
 
      
  
  case 
  
  Array(
  
  0) => println(
  
  "数组中只有一个0")

 
 
 
 
      
  
  case 
  
  Array(x,y) => println(
  
  "数组中包含两个元素")

 
 
 
 
      
  
  case 
  
  Array(x,y,z) => println(
  
  "数组中包含三个元素")

 
 
 
 
      
  
  case 
  
  Array(x,_*) => println(
  
  "这是一个数组，包含多个元素")

 
 
 
 

  
      }

 
 
 
 

  
  

 
 
 
 
    
  
  var myList = 
  
  List(
  
  1,
  
  2,
  
  3)

 
 
 
 

  
      myList match {

 
 
 
 
      
  
  case 
  
  List(
  
  0) => println(
  
  "列表中只有一个0")

 
 
 
 
      
  
  case 
  
  List(x,y) => println(
  
  "列表中包含两个元素，和是" + (x+y))

 
 
 
 
      
  
  case 
  
  List(x,y,z) => println(
  
  "列表中包含三个元素，和是" + (x+y+z))

 
 
 
 
      
  
  case 
  
  List(x,_*) => println(
  
  "列表中包含多个元素，和是" + myList.sum)

 
 
 
 

  
      }

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

6、样本类

定义： case class

 
 

  
  package day5

 
 
 
 

  
  /**

 
 
 
 

  
    * 使用case class 来实现模式匹配

 
 
 
 

  
    */

 
 
 
 

  
  class Vehicle

 
 
 
 

  
  

 
 
 
 

  
  case 
  
  class Car(name:String) extends  Vehicle

 
 
 
 

  
  

 
 
 
 

  
  case 
  
  class Bike(name:String) extends  Vehicle

 
 
 
 

  
  

 
 
 
 

  
  object Demo2 {

 
 
 
 
  
  
  def main(args: 
  
  Array[
  
  String]): 
  
  Unit = {

 
 
 
 
    
  
  var aCar : 
  
  Vehicle = 
  
  new 
  
  Car(
  
  "Car")

 
 
 
 

  
  

 
 
 
 

  
      aCar 
  
  match {

 
 
 
 
      
  
  case 
  
  Car(name) => println(
  
  "汽车 " + name)

 
 
 
 
      
  
  case 
  
  Bike(name) => println(
  
  "自行车 " + name)

 
 
 
 
      
  
  case _ => println(
  
  "其他")

 
 
 
 

  
      }

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

作用：
（1）支持模式匹配，instanceof
（2）定一个 Spark SQL 中的 schema ： 表结构

 
 

  
  scala> 
  
  class Fruit

 
 
 
 

  
  defined 
  
  class Fruit

 
 
 
 

  
  

 
 
 
 

  
  scala> 
  
  class Banana(name:String) extends Fruit

 
 
 
 

  
  defined 
  
  class Banana

 
 
 
 

  
  

 
 
 
 

  
  scala> 
  
  class Apple(name:String) extends Fruit

 
 
 
 

  
  defined 
  
  class Apple

 
 
 
 

  
  

 
 
 
 

  
  scala> 
  
  var a = 
  
  new 
  
  Apple(
  
  "Apple")

 
 
 
 

  
  a: 
  
  Apple = 
  
  Apple@
  
  572e6fd9

 
 
 
 

  
  

 
 
 
 

  
  scala> println(a.isInstanceOf[
  
  Fruit])

 
 
 
 

  
  true

 
 
 
 

  
  

 
 
 
 

  
  scala> println(a.isInstanceOf[
  
  Banana])

 
 
 
 

  
  <console>:
  
  16: warning: fruitless 
  
  type test: a value of 
  
  type Apple cannot also be a Banana

 
 
 
 

  
         println(a.isInstanceOf[
  
  Banana])

 
 
 
 

  
                               ^

 
 
 
 

  
  false

 
 

三、Scala高级特性

1、泛型

和java类似 T

1）泛型类

定义类的时候，可以带有一个泛型的参数
例子：

 
 

  
  package day5

 
 
 
 

  
  

 
 
 
 

  
  /**

 
 
 
 

  
    * 泛型类

 
 
 
 

  
    */

 
 
 
 

  
  

 
 
 
 

  
  //需求：操作一个整数

 
 
 
 

  
  class GenericClassInt{

 
 
 
 
  
  
  //定义一个整数的变量

 
 
 
 
  
  
  private 
  
  var content : 
  
  Int = 
  
  10

 
 
 
 

  
  

 
 
 
 
  
  
  //定义set get

 
 
 
 

  
    def 
  
  set(value : 
  
  Int) = content = value

 
 
 
 

  
    def 
  
  get() : 
  
  Int = content

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  //需求：操作一个字符串

 
 
 
 

  
  class GenericClassString{

 
 
 
 
  
  
  //定义一个空字符串

 
 
 
 
  
  
  private 
  
  var content : 
  
  String = 
  
  ""

 
 
 
 

  
  

 
 
 
 
  
  
  //定义set get

 
 
 
 

  
    def 
  
  set(value : 
  
  String) = content = value

 
 
 
 

  
    def 
  
  get() : 
  
  String = content

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  class GenericClass[T]{

 
 
 
 
  
  
  //定义变量

 
 
 
 
  
  
  //注意：初始值用_来表示

 
 
 
 
  
  
  private 
  
  var content : 
  
  T = 
  
  _

 
 
 
 

  
  

 
 
 
 
  
  
  //定义set get

 
 
 
 

  
    def 
  
  set(value : 
  
  T) = content = value

 
 
 
 

  
    def 
  
  get() : 
  
  T = content

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  object Demo3{

 
 
 
 

  
    def main(args: 
  
  Array[
  
  String]): 
  
  Unit = {

 
 
 
 
    
  
  //定义一个Int 类型

 
 
 
 
    
  
  var v1 = 
  
  new 
  
  GenericClass[
  
  Int]

 
 
 
 

  
      v1.
  
  set(
  
  1000)

 
 
 
 

  
      println(v1.
  
  get())

 
 
 
 

  
  

 
 
 
 
    
  
  //定义一个String 类型

 
 
 
 
    
  
  var v2 = 
  
  new 
  
  GenericClass[
  
  String]

 
 
 
 

  
      v2.
  
  set(
  
  "Ni")

 
 
 
 

  
      println(v2.
  
  get())

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

2）泛型函数

定义一个函数，可以带有一个泛型的参数

 
 

  
  scala> def mkIntArray(elem:
  
  Int*)=
  
  Array[
  
  Int](elem:_*)

 
 
 
 

  
  mkIntArray: (elem: 
  
  Int*)
  
  Array[
  
  Int]

 
 
 
 

  
  

 
 
 
 

  
  scala> mkIntArray(
  
  1,
  
  2,
  
  3)

 
 
 
 

  
  res5: 
  
  Array[
  
  Int] = 
  
  Array(
  
  1, 
  
  2, 
  
  3)

 
 
 
 

  
  

 
 
 
 

  
  scala> mkIntArray(
  
  1,
  
  2,
  
  3,
  
  4,
  
  5)

 
 
 
 

  
  res6: 
  
  Array[
  
  Int] = 
  
  Array(
  
  1, 
  
  2, 
  
  3, 
  
  4, 
  
  5)

 
 
 
 

  
  

 
 
 
 

  
  scala> def mkStringArray(elem:
  
  String*)=
  
  Array[
  
  String](elem:_*)

 
 
 
 

  
  mkStringArray: (elem: 
  
  String*)
  
  Array[
  
  String]

 
 
 
 

  
  

 
 
 
 

  
  scala> mkStringArray(
  
  "a",
  
  "b")

 
 
 
 

  
  res7: 
  
  Array[
  
  String] = 
  
  Array(a, b)

 
 
 
 

  
  

 
 
 
 

  
  scala> def mkArray[T:ClassTag]

 
 
 
 

  
  

 
 
 
 

  
  ClassTag ： 表示scala在运行时候的状态信息，这里表示调用时候数据类型

 
 
 
 

  
  

 
 
 
 

  
  scala> 
  
  import scala.reflect.ClassTag

 
 
 
 

  
  import scala.reflect.ClassTag

 
 
 
 

  
  

 
 
 
 

  
  scala> def mkArray[T:ClassTag](elem:T*) = 
  
  Array[T](elem:_*)

 
 
 
 

  
  mkArray: [T](elem: T*)(implicit evidence$
  
  1: scala.reflect.ClassTag[T])
  
  Array[T]

 
 
 
 

  
  

 
 
 
 

  
  scala> mkArray(
  
  1,
  
  2)

 
 
 
 

  
  res8: 
  
  Array[
  
  Int] = 
  
  Array(
  
  1, 
  
  2)

 
 
 
 

  
  

 
 
 
 

  
  scala> mkArray(
  
  "Hello",
  
  "aaa")

 
 
 
 

  
  res9: 
  
  Array[
  
  String] = 
  
  Array(Hello, aaa)

 
 
 
 

  
  

 
 
 
 

  
  scala> mkArray(
  
  "Hello",
  
  1)

 
 
 
 

  
  res10: 
  
  Array[
  
  Any] = 
  
  Array(Hello, 
  
  1)

 
 

泛型：但凡有重复的时候，考虑使用泛型

3）上界和下界

Int x
规定x的取值范围 100 <= x <=1000

泛型的取值范围：
T

类的继承关系 A —> B —> C —> D 箭头指向子类

定义T的取值范围 D <: T <: B

T 的 取值范围 就是 B C D

<: 就是上下界的表示方法

概念
上界 S <： T 规定了 S的类型必须是 T的子类或本身
下界 U >： T 规定了 U的类型必须是 T的父类或本身

例子：

 
 

  
  package day5

 
 
 
 

  
  /**

 
 
 
 

  
    * 主界

 
 
 
 

  
    */

 
 
 
 

  
  //定义父类

 
 
 
 

  
  class Vehicle{

 
 
 
 
  
  
  //函数：驾驶

 
 
 
 
  
  
  def drive() = println(
  
  "Driving")

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  //定义两个子类

 
 
 
 

  
  class Car extends Vehicle{

 
 
 
 
  
  
  override 
  
  def drive() : 
  
  Unit = println(
  
  "Car Driving")

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  //class Bike extends Vehicle{

 
 
 
 

  
  //  override def drive(): Unit = println("Bike Driving")

 
 
 
 

  
  //}

 
 
 
 

  
  

 
 
 
 

  
  class Bike{

 
 
 
 
  
  
  def drive(): 
  
  Unit = println(
  
  "Bike Driving")

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  object ScalaUpperBoud {

 
 
 
 
  
  
  //定义驾驶交通工具的函数

 
 
 
 
  
  
  def takeVehicle[
  
  T <: 
  
  Vehicle](v:
  
  T) = v.drive()

 
 
 
 

  
  

 
 
 
 
  
  
  def main(args: 
  
  Array[
  
  String]): 
  
  Unit = {

 
 
 
 
    
  
  //定义交通工具

 
 
 
 
    
  
  var v : 
  
  Vehicle = 
  
  new 
  
  Vehicle

 
 
 
 

  
      takeVehicle(v)

 
 
 
 

  
  

 
 
 
 
    
  
  var c : 
  
  Car = 
  
  new 
  
  Car

 
 
 
 

  
      takeVehicle(c)

 
 
 
 

  
  

 
 
 
 
    
  
  //因为没有继承Vehicle，所以运行报错

 
 
 
 
    
  
  var b : 
  
  Bike = 
  
  new 
  
  Bike

 
 
 
 

  
      takeVehicle(b)

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

 
 

  
  scala> def addTwoString[
  
  T <: String](
  
  x:T,y:T) = x +" 
  
  *****
  
  **** " + y

 
 
 
 

  
  addTwoString: [
  
  T <: String](
  
  x: T, y: T)String

 
 
 
 

  
  

 
 
 
 

  
  scala> addTwoString("Hello","World")

 
 
 
 

  
  res11: String = Hello 
  
  *****
  
  **** World

 
 
 
 

  
  

 
 
 
 

  
  scala> addTwoString(1,2)

 
 
 
 

  
  <console>:14: error: inferred type arguments [Int] do not conform to method addTwoString's type parameter bounds [T 
  
  <: String]

 
 
 
 

  
         addTwoString(1,2)

 
 
 
 

  
         ^

 
 
 
 

  
  <console>:14: error: type mismatch;

 
 
 
 

  
   found   : Int(1)

 
 
 
 

  
   required: T

 
 
 
 

  
         addTwoString(1,2)

 
 
 
 

  
                      ^

 
 
 
 

  
  <console>:14: error: type mismatch;

 
 
 
 

  
   found   : Int(2)

 
 
 
 

  
   required: T

 
 
 
 

  
         addTwoString(1,2)

 
 
 
 

  
                        ^

 
 
 
 

  
  

 
 
 
 

  
  scala> addTwoString(1.toString,2.toString)

 
 
 
 

  
  res13: String = 1 
  
  *****
  
  **** 2

 
 

4）视图界定 View bounds

就是上界和下界的扩展

除了可以接收上界和下界规定的类型以外，还可以接收能够通过隐式转换过去的类型

用 % 来表示

 
 

  
  scala>  def addTwoString[T <% String](x:T,y:T) = x +
  
  " ********* " + y

 
 
 
 

  
  addTwoString: [T](x: T, y: T)(
  
  implicit evidence$
  
  1: T => String)String

 
 
 
 

  
  

 
 
 
 

  
  scala> addTwoString(
  
  1,
  
  2)

 
 
 
 

  
  <console>:
  
  14: error: No 
  
  implicit view available from 
  
  Int => String.

 
 
 
 

  
         addTwoString(
  
  1,
  
  2)

 
 
 
 

  
                     ^

 
 
 
 

  
  //定义隐式转换函数

 
 
 
 

  
  scala> 
  
  implicit def int2String(n:
  
  Int):String = n.toString

 
 
 
 

  
  warning: there was one feature warning; re-run with -feature for details

 
 
 
 

  
  int2String: (n: 
  
  Int)String

 
 
 
 

  
  

 
 
 
 

  
  scala> addTwoString(
  
  1,
  
  2)

 
 
 
 

  
  res14: String = 
  
  1 ********* 
  
  2

 
 

执行过程：
1、调用了 int2String Int => String
2、addTwoString(“1”,”2”)

5）协变和逆变（概念）

协变：表示在类型参数前面加上 + 。泛型变量的值，可以是本身类型或者其子类类型
例子：

 
 

  
  package day5

 
 
 
 

  
  

 
 
 
 

  
  /**

 
 
 
 

  
    * 协变：表示在类型参数前面加上 + 。泛型变量的值，可以是本身类型或者其子类类型

 
 
 
 

  
    */

 
 
 
 

  
  

 
 
 
 

  
  class Animal

 
 
 
 

  
  

 
 
 
 

  
  class Bird extends Animal

 
 
 
 

  
  

 
 
 
 

  
  class Sparrow extends Bird

 
 
 
 

  
  

 
 
 
 

  
  //定义第四个类，吃东西的类，协变，有继承关系了

 
 
 
 

  
  class EatSomething[+T](t:T)

 
 
 
 

  
  

 
 
 
 

  
  object Demo4 {

 
 
 
 
  
  
  def main(args: 
  
  Array[
  
  String]): 
  
  Unit = {

 
 
 
 
    
  
  //定义一个鸟吃东西的对象

 
 
 
 
    
  
  var c1 : 
  
  EatSomething[
  
  Bird] =
  
  new 
  
  EatSomething[
  
  Bird](
  
  new 
  
  Bird)

 
 
 
 

  
  

 
 
 
 
    
  
  //定义一个动物吃东西的对象

 
 
 
 
    
  
  var c2 : 
  
  EatSomething[
  
  Animal] = c1

 
 
 
 

  
  

 
 
 
 
    
  
  /**

 
 
 
 

  
        * 问题：能否把c1 赋给c2

 
 
 
 

  
        * c1 c2都是EatSomething

 
 
 
 

  
        * c1 c2 没有继承关系

 
 
 
 

  
        *

 
 
 
 

  
        * class EatSomething[T](t:T)

 
 
 
 

  
        * var c2 : EatSomething[Animal] = c1  报错

 
 
 
 

  
        * 原因 ： EatSomething[Bird] 并没有继承EatSomething[Animal]

 
 
 
 

  
        *

 
 
 
 

  
        * class EatSomething[+T](t:T)

 
 
 
 

  
        * 报错消失

 
 
 
 

  
        *

 
 
 
 

  
        * 协变

 
 
 
 

  
        */

 
 
 
 

  
  

 
 
 
 
    
  
  var c3 : 
  
  EatSomething[
  
  Sparrow] = 
  
  new 
  
  EatSomething[
  
  Sparrow](
  
  new 
  
  Sparrow)

 
 
 
 
    
  
  var c4 : 
  
  EatSomething[
  
  Animal] = c3

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

逆变：表示在类型参数前面加上 - 。泛型变量的值，可以是本身类型或者其父类类型
例子：

 
 

  
  package day5

 
 
 
 

  
  

 
 
 
 

  
  /**

 
 
 
 

  
    * 逆变：表示在类型参数前面加上 - 。泛型变量的值，可以是本身类型或者其父类类型

 
 
 
 

  
    */

 
 
 
 

  
  

 
 
 
 

  
  class Animal

 
 
 
 

  
  

 
 
 
 

  
  class Bird extends Animal

 
 
 
 

  
  

 
 
 
 

  
  class Sparrow extends Bird

 
 
 
 

  
  

 
 
 
 

  
  //定义第四个类，吃东西的类，逆变

 
 
 
 

  
  class EatSomething[-T](t:T)

 
 
 
 

  
  

 
 
 
 

  
  object Demo5 {

 
 
 
 
  
  
  def main(args: 
  
  Array[
  
  String]): 
  
  Unit = {

 
 
 
 
    
  
  //定义一个鸟吃东西的对象

 
 
 
 
    
  
  var c1 : 
  
  EatSomething[
  
  Bird] =
  
  new 
  
  EatSomething[
  
  Bird](
  
  new 
  
  Bird)

 
 
 
 

  
  

 
 
 
 
    
  
  //定义一个动物吃东西的对象

 
 
 
 
    
  
  var c2 : 
  
  EatSomething[
  
  Sparrow] = c1

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

2、隐式转换

1）隐式转换函数： implicit

 
 

  
  package day5

 
 
 
 

  
  

 
 
 
 

  
  /**

 
 
 
 

  
    * 隐式转换

 
 
 
 

  
    *

 
 
 
 

  
    * 定义一个隐式转换函数

 
 
 
 

  
    */

 
 
 
 

  
  class Fruit(name:String){

 
 
 
 
  
  
  def getFruitName() : 
  
  String = name

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  class Monkey(f:Fruit){

 
 
 
 
  
  
  def say()  = println(
  
  "Monkey like " + f.getFruitName())

 
 
 
 

  
  }

 
 
 
 

  
  

 
 
 
 

  
  object ImplicitDemo {

 
 
 
 

  
  

 
 
 
 
  
  
  def main(args: 
  
  Array[
  
  String]): 
  
  Unit = {

 
 
 
 
    
  
  //定义一个水果对象

 
 
 
 
    
  
  var f : 
  
  Fruit = 
  
  new 
  
  Fruit(
  
  "Banana")

 
 
 
 

  
      f.say()

 
 
 
 

  
    }

 
 
 
 

  
  

 
 
 
 
  
  
  implicit 
  
  def fruit2Monkey(f:
  
  Fruit) : 
  
  Monkey = {

 
 
 
 
    
  
  new 
  
  Monkey(f)

 
 
 
 

  
    }

 
 
 
 

  
  }

 
 

2）隐式参数：使用implicit 修饰的函数参数

定义一个带有隐式参数的函数：

 
 

  
  scala> def testPara(
  
  implicit 
  
  name:String) = println(
  
  "The value is " + 
  
  name)

 
 
 
 

  
  testPara: (
  
  implicit 
  
  name: String)
  
  Unit

 
 
 
 

  
  

 
 
 
 

  
  scala> testPara(
  
  "AAAA")

 
 
 
 

  
  The 
  
  value is AAAA

 
 
 
 

  
  

 
 
 
 

  
  scala> 
  
  implicit val 
  
  name : String = 
  
  "*****"

 
 
 
 

  
  name: String = *****

 
 
 
 

  
  

 
 
 
 

  
  scala> testPara

 
 
 
 

  
  The 
  
  value is *****

 
 

定义一个隐式参数，找到两个值中比较小的那个值
100 23 –>23
“Hello” “ABC” –> ABC

 
 

  
  scala> def smaller[T](a:T,b:T)(
  
  implicit order : T => Ordered[T]) = 
  
  if(a<b) a 
  
  else b

 
 
 
 

  
  smaller: [T](a: T, b: T)(
  
  implicit order: T => Ordered[T])T

 
 
 
 

  
  

 
 
 
 

  
  scala> smaller(
  
  1,
  
  2)

 
 
 
 

  
  res18: 
  
  Int = 
  
  1

 
 
 
 

  
  

 
 
 
 

  
  scala> smaller(
  
  "Hello",
  
  "ABC")

 
 
 
 

  
  res19: String = ABC

 
 

解释：
order 就是一个隐式参数，我们使用Scala中的 Ordered 类，表示该值可以被排序，也就是可以被比较

作用：扩充了属性的功能

3）隐式类 在类名前 加 implicit 关键字
作用：扩充类的功能

 
 

  
  package day5

 
 
 
 

  
  

 
 
 
 

  
  /**

 
 
 
 

  
    * 隐式类

 
 
 
 

  
    */

 
 
 
 

  
  object Demo6 {

 
 
 
 
  
  
  def main(args: 
  
  Array[
  
  String]): 
  
  Unit = {

 
 
 
 
    
  
  //执行两个数字的求和

 
 
 
 

  
      println(
  
  "两个数字的和是： "+
  
  1.add(
  
  2))

 
 
 
 

  
  

 
 
 
 
    
  
  /**

 
 
 
 

  
        * 定义一个隐式类，类增强1的功能

 
 
 
 

  
        *

 
 
 
 

  
        * Calc(x:Int)

 
 
 
 

  
        * 1是Int类型，所以就会传递进来

 
 
 
 

  
        *

 
 
 
 

  
        * 执行过程：

 
 
 
 

  
        * 1--->Calc类

 
 
 
 

  
        * var a = new Calc(1)

 
 
 
 

  
        * 在调用Calc add方法

 
 
 
 

  
        * a.add(2)

 
 
 
 

  
        *

 
 
 
 

  
        */

 
 
 
 
    
  
  implicit 
  
  class Calc(x:Int){

 
 
 
 
      
  
  def add(y: 
  
  Int) : 
  
  Int = x + y

 
 
 
 

  
      }

 
 
 
 

  
    }

 
 
 
 

  
  }