1.基本语法

在Scala中的模式匹配类似于Java中的switch语法

//模式匹配基本语法
	val a=10
    val b=20
    val c="+"

    c match {
      case "+" =>println(a+b)
      case "-"=>println(a-b)
      case "/"=>println(a/b)
      case "*"=>println(a*b)
      case _=>println("没有匹配上边的情况")

运行结果

2.模式守卫

如果在模式匹配中想要表达匹配某个范围的数据，就需要在模式匹配中添加条件守卫。

    //返回整数的绝对值
    var d1= -3.14
    val d = d1 match {
      case d2: Double if d2 > 0 => d2
      case d2: Double if d2 <= 0 => -d1
      case _ => 0
    }
    println(d)

3.匹配常量和类型

在scala中可以通过模式匹配来匹配常量和类型。
如果不使用模式匹配来获取参数的类型的话，可以通过if和isInstanceOf

    //第一种方式，通过if
    def fun(x:Any)={
      if(x.isInstanceOf[String])
        {
          println("这是字符串")
        }
        if(x.isInstanceOf[Int])
          {
            println("这是整数")
          }
          if(x.isInstanceOf[Double])
            {
              println("这是浮点类型")
            }
    }

    fun("222")

下面是使用了模式匹配来获取参数的类型

    //通过模式匹配
    def fun(x:Any)={
      x match {
        case s:String=>{
          println("这是字符串")
        }
        case i:Int=>{
          println("这是整数")
        }
        case d:Double=>{
          println("这是浮点类型")
        }
        case _ => {
        println("其他")
      }
      }
    }
    fun("222")

4.匹配对象和样例类

4.1 匹配对象

在scala中也可以使用模式匹配来匹配对象，在匹配对象的时候，需要有类中有apply和unapply方法。

class Person14(val name:String,var age:Int){


}
object Person14{
  def apply(name: String, age: Int): Person14 = new Person14(name, age)

  //unapply方法 解析方法
  //就是将类的对象当成参数传入此方法中，用于获取对象创建的参数
  def unapply(arg: Person14): Option[(String, Int)] = {
    if(arg==null)
      {
        None
      }
      else
      {
        val tuple = (arg.name, arg.age)
        //将参数传入到包装类中返回
        Some(tuple)
      }
  }

测试方法中：

val person14 = Person14("zhangsan", 22)
    person14 match {
      case Person14("zhangsan",22) =>println("找到zhangsan")
      case _ => println("其他情况")
    }

Scala中 unapply方法和 apply 方法相反，
apply是传递一个参数生成一个类， Unapply方法是 根据传递的类 获取参数，逆向的过程
上述代码中引入了包装类，option、some、None。其中some和None为option的子类，如果值为空，就将None返回，如果值不为空，就将值传入到Some中返回。

4.2 匹配样例类

什么是样例类？
1.样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，比如：apply,unapply,toString,equals,hashCode和copy方法
2.样例类是为模式匹配而优化的类，因为默认提供了unapply方法，因此样例类可以直接使用模式匹配，无需自己实现unapply方法
3.构造器中每一个参数都是val。

5.偏函数中的模式匹配

偏函数也是函数的一种，通过偏函数我们可以方便的对输入参数做更精确的检查。
偏函数的诞生就是为了方便模式匹配，例如：该偏函数的输入类型为List[Int],我们需要的是第一个元素是0的集合,这种就是通过模式匹配来实现的。
偏函数自动实现了filter和map方法。

    //1.偏函数的复杂写法
    val partialFun = new PartialFunction[List[Int], Int] {
      //偏函数在什么情况使用
      override def isDefinedAt(x: List[Int]): Boolean = {
        x match {
          case List(x, y, _*) => true //在这种情况下使用偏函数
          case _ => false //其他情况下不使用
        }
      }

      //偏函数怎么用
      override def apply(v1: List[Int]): Int = {
        v1 match {
          case List(x, y, _*) => y
        }
      }
    }
    //2.偏函数简单写法
    val parFunc1: List[Int] => Int = (list: List[Int]) => list match {
      case List(x, y, _*) => y
    }


    //通过collect方法调用偏函数
    val list2 = List(List(1, 2, 3, 4), List(1), List(5, 6))
    val list3 = list2.collect({
      case List(x, y, _*) => y
    })
    val list4 = list2.collect(partialFun)

    println(list3)
    println(list4)

运行结果：

需求：使用偏函数来改变一个二元组

//第一种方式，可以使用map方法来对二元组进行改造
    val list5 = List(("hello", 1), ("world", 2))
    //使用map方法来改造二元组
    val mapChange = list5.map((tuple: (String, Int)) => {
      (tuple._1 + "111", tuple._2 + 1)
    })
    print(mapChange)
//第二种方式，就是使用偏函数来实现对二元组的改造
    val parChange = list5.collect({
      case (key, value) => (key + "111", value + 1)
    })

    println(parChange)

运行结果：