2021-05-17

匹配

模式匹配基本语法

模式匹配
函数编程语言的标配
有点类似java的switch
基本使用：
要匹配的值 match{
case 选项=》
// 代码
case 选项=》
//代码
…

package com.syf.scala1015day06

import scala.io.StdIn

/**
  * Author Amily
  * Date 2021/5/17
  */
object PatternDemo1 {
  def main(args: Array[String]): Unit = {
    val a:Int=10
    val b:Int=20
    val op:String =StdIn.readLine("请输入一个运算符：")
    op match{
      case "+"=>
        println(a + b)
      case "-"=>
        println(a - b)
      case "*"=>
        println(a * b)
      case "/"=>
        println(a / b)
      case _=>
        println("你的运算符输入的不对")

    }
  }
}

匹配变量和常量

匹配变量
case aa
aa是新声明的，只能在这个case内使用
case Ba
变量是大写字母开头，Scala认为这个变量是一个常量，必须是已经定义好的常量
匹配常量：
1.首字母大写
2.aA
case _
本质就是匹配变量，只是把变量名字省略了

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object PatternDemo2 {
  def main(args: Array[String]): Unit = {
//    val a:Int=20
//    a match {
//        //case语句类新声明的变量
//      case aa=> println(aa)
//      case 20=> println(20)
//    }
val a:Int=20
    val aA:Int=20
       a match {
         case a=> println(a)
         case `aA`=> println(aA)
       }
  }
}

模式匹配的值

任何的语法结构都有值!
模式匹配也有值，他的值就是匹配成功的那个case的最后一行代码的值

package com.syf.scala1015day06

import scala.io.StdIn

/**
* Author Amily
* Date 2021/5/17
*/
object PatternDemo3 {
  def main(args: Array[String]): Unit = {
    val a:Int=10
    val b:Int=20
    val op:String =StdIn.readLine("请输入一个运算符：")
    val r:Int=op match{
      case "+"=>
        a + b
      case "-"=>
        a - b
      case "*"=>
        a * b
      case "/"=>
        a / b
      case _=>
        -1

    }
    println(r)
  }
}

守卫和匹配类型

基本使用
匹配变量和常量
区别
模式匹配的值
匹配类型：

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object PatternDemo4 {
  def main(args: Array[String]): Unit = {
    val a:Any=10
    a match {
      case a :Int if a>10=> println(a + 10)
      case s:String=> println(s.toUpperCase())
      case b:Boolean=> println(b)
      case _=>
    }
  }
}

泛型的类型匹配

new int[] new String[]
数组在是Scala中表面用到了泛型，实际不是泛型
除了数组其他的所有泛型都是真正的泛型
泛型模式的匹配是无法匹配出泛型的类型的
泛型擦除：
泛型的存在是为了在编译的时候类型更安全
泛型值存在于源码和编译的时候，编译成字节码之后，泛型就不存在了

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object PatternDemo5 {
  def main(args: Array[String]): Unit = {
//    val arr:Array[Int]=Array[Int](1,2)
    val arr:Any=List[Double](1.1,2,3)
    arr match {
//      case a:Array[Int]=> println("Array[Int]")
//      case a:Array[Double]=> println("Array[Double]")
        //匹配任意数组
//      case a:Array[_]=> println("Array[Double]")
//      case a:List[Int]=> println("List[Int]")
      case a:List[_]=> println("List[_]")
    }
  }
}

匹配数组

模式匹配深入到集合的内部：
有顺序的集合

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object PatternDemo6 {
  def main(args: Array[String]): Unit = {
    val arr :Array[Int]=Array(2,2,3,4)
    arr match {
      case Array(1,2,a,b)=>
//        println("Array(1,2,_,_)")
//        println("Array(1,2,a,b)")
//        println(a, b)
//      case Array(2,2,_*)=>
//        println("Array(2,2,_*)")
      case Array(2,2,abc@_*)=>
        println(abc.toList)
    }
  }
}

元素匹配

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object PatternDemo7 {
  def main(args: Array[String]): Unit = {
    val t:(String,Int)=("lisi",20)
    t match {
//      case (name,age)=> println(name)
      case (name:String,age)=> println(name)
    }
  }
}

List匹配

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object PatternDemo8 {
  def main(args: Array[String]): Unit = {
     val list :List[Int]=List(10,20,30,40)
    list match {
//      case List(a,b,c,d)=>
//        println("List(a,b,$c,$d)")
//      case List(10,abc@_*)=>
//        println(abc)
//      case a::b::c::d::Nil=>
//        println(a)
//      case a::rest=>
//        println(rest)
      case a::b::c=>
        //最后一个一定是集合
        println(a)
        println(b)
        println(c)
    }
  }
}

Option的使用

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object OptionDemo1 {
  def main(args: Array[String]): Unit = {
//    val op:Option[Int]=get
//    if(op.isDefined){
//      println(op.get)
//    }
    val op:Option[Double]=sqrt(-9)
    if (op.isDefined) {
      println(op.get)
    }else{
      println("没有平方根")
    }
  }
  def sqrt(n:Double)={
    if(n>=0) Some(math.sqrt(n))
    else None
  }
 def get:Option[Int]= Some(10)
}

模式匹配中的对象匹配

case Person(age,name)=>
会去调用People 伴生对象的unapply

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
class People(val age:Int,val name:String)
object People{
  def unapply(pp:People):Option[(Int,String)]=if(pp!=null){
    Some(pp.age,pp.name)
  }else{
    None
  }
}
object ObjMatch {
  def main(args: Array[String]): Unit = {
    val p:People=new People(10,"zhiling")
    p match {
      case People(age,name)=> println(age,name)
      case _ =>


    }
  }
}

对象匹配的案例

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object Sqrt {
  def unapply(d:Double) :Option[Double] =
    if (d>0)Some(math.sqrt(d))
    else None

}
object ObjMatch1 {
  def main(args: Array[String]): Unit = {
    //使用对象匹配的方式把一个数的平方根匹配出来
    val d:Double=9
    d match {
      case Sqrt(a)=> println(a)
    }
  }
}
/*

 */

匹配序列

对象匹配的基本原理：
对象的unapply或unapplySeq

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
object MyArray{
  def unapplySeq(s:String)=
    if(s!=null)
      Some(s.split(",").toList)
    else None

}
object ObjMatch2 {
  def main(args: Array[String]): Unit = {
    val names:String ="lisi,zhangsan,wangwu,zhiling,fengjie"
    names match{
      case MyArray(a,b,rest@_*)=>
        println(a)
        println(b)
        println(rest)
    }
  }
}

样例类

package com.syf.scala1015day06
/**
  * Author Amily
  * Date 2021/5/17
  */
case class  User(age:Int,name:String)
object CaseDemo1 {
  def main(args: Array[String]): Unit = {
    val user:User=User(10,"lisi")
    user match {
      case User(age,name)=> println(age)
    }
  }
}
/*
样例类：
  apply
  unapply
  equals
  hashCode
    ....
 判断数据：
     通讯协调
 */