Scala模式匹配--样例类--密封样例类--偏函数

Scala模式匹配--样例类--密封样例类--偏函数

模式匹配

等价于java的switch case
        val c = '+'
        c match{
            case '+' => println(111)
            case '-' => println(222)
            case _ => println(0)
        }

匹配常量

//匹配值，没有break
val x :Char= '+'
//万一xx存在这种可能case '-'=>"100" case _=>0.0F
//val xx :Int=x match{
val xx :Any=x match{ //Any所有类的超类
  case '+'=>100
  case '-'=>"100"
  case _=>0.0F
}

守卫条件

val x = c match{
          case '+' => 1
          case '-' => -1
          case _ if Character.isDigit(c) => 'N'
   //case _if x.isDigit=>0.0F 它如果是数字
          case _ => 'X'
        }
val x :Char='9'
val xx:Any=x match{
  case '+'=>100
  case '-'=>"100"
  case _if x.isDigit=>println("is number")  //if x.isDigit这里就是守卫条件
  case _=>println(x)
}
//守卫可以是任何Boolean条件。
注意模式总是从上往下进行匹配。如果带守卫的这个模式不能匹配，则捕获所有的模式(case_)会被用来尝试进行匹配。

使用变量：如果case关键字后面跟着一个变量名，那么匹配的表达是会被赋值给那个变量。

val str = "hello"
        str(0) match{
          case '+' => println(1)
          case '-' => println(2)
          case ch => println(ch)
        }

常量问题,大写会识别成常量，小写是变量，如果让小写也是常量，使用``标出

val str = "hello"
        val ch = 'h'
        str(0) match{
          case '+' => println(1)
          case '-' => println(2)
          case `ch` => println(`ch`)
        }

类型匹配

val x:Any = "abc"
        x match{
          case a:Int => println(1)
          case a:String => println(2)
          case a:Float => println(3)
          case _ => println(0)
        }

匹配数组

val arr=Array(0)        //  100 is Int
val arr=Array(0,1)      //2=>x:0
val arr=Array(0,1,2,3) //default
arr match{
    //精确匹配
    case Array(0)=>println(1)  
    //匹配两个元素
    case Array(x,y)=>println(2+"=>x: "+x)
    //匹配0为首个元素
    case Array(0,_*)=>println(3)
    case _=>println("default")
}

val arr = Array[Int](1,2,3)
        arr match{
          //case Array(0) => println(1)         //精确匹配(0)
          case Array(x,y) => println(2)         //匹配2个元素
          case Array(0,_*) => println(3)        //匹配0开始
          case _ => println(4)                  //
        }
总结：第一个模式匹配包含0的数组。第二个模式匹配任何带有两个元素的数组，并且将这两个元素分别绑定到变量x和y中。第三个表达式匹配任何以零开始的数组。

匹配集合（List）

val list = 0::1::2::Nil
        list match{
          case 0::Nil => println(1)             //0
          case x::y::Nil => println(2)          //x,y
          case 0::tail => println(3)                   //0,...
          case _ => println(4)
        }

val list=1::2::Nil      //2 =>x: 1
val list=0::1::2::Nil   //List(1,2)
list match{
    //精确匹配
    case 0::Nil=>println(1)
    //匹配两个元素
    case x::y::Nil=>println(2+"=>x: "+x)
    //匹配0为首个元素
    case 0::tail=>println(tail)
    case _=>println("default")
}

匹配元组

val t = (1,2)
        t match{
          case (0,_) => println(1)
          case (y,0) => println(2)
          case _ => println(3)
        }
val t=(0,1) //100
val t=(1,0) //200  必须符合case里面的条件才行
t match{
   case(0,_)=>println("100")
   case(x,0)=>println("200")
   case _ =>println("default")
}

val(x,y)=(1,2)
同时把x定义为1，把y定义为2.这对于使用那些返回对偶的函数而言很有用
val (q,r)=BigInt(10)/%3
/%方法返回包含商和余数的对偶，而这两个值分别被变量q和r捕获到。

提取器unapply / unapplySeq

val arr = Array(1,2,3)
        arr match{
          case Array(x,y,z)=> printf("x=%d,y=%d,z=%d" , x , y  ,z)
          case _ => println("0")
        }
scala> val t=<1,2>
t:<Int,Int>=<1,2>
scala> val<x,y>=t  //可以同时把t给抽出来
x:Int=1
y:Int=2
scala> val<x,y>=t

//反向抽取
//如果元素很多，可以用t给抽出来
scala>val t=<1,"tom",12,"henan">
t:<Int,String,Int,String>=<1,tom,12,henan>
scala>val<id,name,age,addr>=t
id:Int=1
name:String=tom
age:Int=12
addr:String=henan

多个变量声明模式

val (x,y,z) = (1,2,3)
        x = 1
        y = 2
        z = 3
//模式匹配的变量声明模式
val t=(1,"tom",12,"henan")  //这个就是元组
val (id,name,age,addr)=t
println(id)
[源码解析]
Tuple4  extends(继承)Product4
object Product4{
  def unapply[T1,T2,T3,T4]  (x:Product4[T1,T2,T3,T4]):Option[Product4[T1,T2,T3,T4]]=Some(x)
  option类型(Some（类） , None(单例对象))
}
------------------
//同时提取商和余数
val (a,b)=BigInt(5) /% 3
val arr=Array(1,2,3,4)
val Array(x,y,_*)=arr  //for循环的map迭代
println(x+","+y)//1,2
val map=Map(1->"tom1",2->"tom2")
//相当于反向抽取(常见的形式)
for((k,y)<-map ){
  println(k+"="+v)
}

抽取前两个元素依次赋值

val Array(x,y,_*) = Array(1,2,3,4,5)

        val map = Map(1->"tom1" , 2->"tom2",3->"tom3")
        for((k,_) <- map) println(k)
        for(t <- map) println(t._1)
//模式匹配的变量声明模式

样例类

.样例类是一种特殊的类，它们经过优化以被用于模式匹配。内置实现了很多便捷的方法，比如apply/unapply/serilizable/compare/toString

abstact classAmount  //一个抽象类
//定义了两个样例类
case class Dollar(value:Double)extends Amount
case class Currency(value: Double,unit: String)extends Amount  //样例类必须要有属性
//通过普通类定义一个子类，它和样例类有啥区别
object CaseClassDemo{
  def main(args:Array[String]):Unit={
    abstract class Amount
    //定义样例类  
    //sealed（密封），样例子类和样例父类如果不加sealed是可以定义在不同的scala文件里的 如果加了sealed就必须跟它的父类定义在同一个Scala文件中
    //case class Dollar(cnt:Int)extends Amount样例子类，sealed的优点是：在一个scala文件中可以找到它所有的sealed子类，就不会存在在其它的包里面或文件夹里面。
    sealed case class Dollar(cnt:Int)extends Amount
    case class RenmiYuan(cnt:Int)extends Amount
    //定义一个样例对象
    case object NoMoney extends Amount
    //可以实例化对象（快速构建对象）
    //apply
    val d1=Dollar(10)
    //apply
    val r1=RenmiYuan(100)
    //打印      --因为里面已经重新了toString方法
    println(d1)  //Dollar(10)
    println(r1)  //RenmiYuan(100)
    //快速抽出里面的属性
    //unapply
    val Dollar(x)=d1  //10
     //unapply
    val RenmiYuan(y)=r1 //100
    println(x)
    //Serializable(scala)继承java里面的，就是java里面的串行化接口实现
    package scala
    trait Serializable extends Any with java.io.Serializable
 -------------样例对象模式匹配----------------- 
    //给样例对象变量，是否可以模式匹配，这里用到的都是unapply反解析
    val m=Dollar(300)    //300美元 
    val m:Amount=RenmiYuan（300）//300人民币
    val m:Amount=NoMoney  //NoMoney本来就是样例对象
    //模式匹配，判断它是美元还是人民币
    //对样例实例进行模式匹配
    m match{
      case Dollar(x)=>println(x+"美元")
      case RenmiYuan(y)=>println(y+"人民币")
      case NoMoney=>println("没钱")
    }
  }
}

密封样例类

必须将样例子类和父类定义在一个scala文件中。
方便在一个scala文件中找到所有的子类。不允许在其他地方定义
子类。和匹配模式配合使用，非常方便。
//sealed 密封
sealed abstract class Dog
case class Jing8(var name:String) extends Dog
case class Shapi(var name:String) extends Dog
[典型的密封样例类源码]
//Option密封抽象类
sealed abstract class Option[+A]extends Product with Serializable
它的两个子类 None  Some
//None子对象(样例对象)
case object None extends Option[Nothing]{
  def isEmpty=true
  def get=throw new NoSuchElementException("None.get")
}
//Some（样例类）
final case class Some[+A](x: A)extends Option[A]{
  def isEmpty=false
  def get=x
}

偏函数(PartialFunction)

被包在花括号内的一组case语句是一个偏函数---一个并非对所有输入值都有定义的函数。它是PartialFunction[A,B]类的一个实例。(A是参数类型，B是返回类型。)该类有两个方法：apply方法从匹配到模式技术函数值，而isDefinedAt方法在输入至少匹配其中一个模式时返回true.

模式匹配有一个缺点就是代码需要重用，假如很多地方需要用到模式匹配。就需要反复的写这些东西，完全可以{}包起来的一组case给它封装成一个对象，这个对象就叫做偏函数。偏函数还有一种情况就是，它没有完全把所有的情况罗列完整。它只是一部分，或者是若干情况。
偏函数的作用：偏函数就是对模式匹配代码进行重用，以备于在其它的地方还可以利用这段代码执行模式匹配的动作。
//偏函数，对模式匹配的封装，重用模式匹配的代码
object PartialFunctionDemo{
  def main(args:Array[String]):Unit={
    val ch:Char='+'
    val r=ch match{
      case '+'=>1
      case '-'=>-1
      case _=>0
    }
    println(r) //1
    //定义一个偏函数对象（类）,代码就是把case放进去
    val f:PartialFunction[Char,Int]={
      case '+'=>1
      case '-'=>-1
      case _=>0
    }
    //isDefinedAt是否定义了这种情况，它是判断是否有没有定义这种情况的处理
    println(f.isDefinedAt('+')) //1
    println(f.isDefinedAt('9')) //true  如果把//case _=>0注释点就 false
    //调用这个
    println(f.apply('+')) //1
    //可以简写
    println(f('-'))   //-1
    println(f('9'))//注释掉 case _=>0，则抛异常(MatchError)没有定义这个数
  }
}