模式匹配

1.普通匹配

//简单不聊
//todo 常量匹配
    def testAge(age:Int)={
      age match {
        case 10 => println("10")
        case 20 => println("20")
        case _ => println("其他")
      }
    }
    testAge(20)

    //todo 类型匹配
    def testType(x:Any)={
      x match {
        case x:Int => println("整型")
        case x:List[Int] => println("List")
        case x:String =>println("字符串")
        case _ => println("其他")
      }
    }
    testType(List("a"))//类型不考虑
  }

  //todo 匹配集合
  private val list = List(1, 2, 5)
  list match {
    case first::second::rest => println(first + "_" + second + "_" + rest)
    case _ => println("some else")
  }

  //todo 匹配元组
  for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) {
    val result = tuple match {//可以返回
      case (0, _) => "0 ..." //是第一个元素是0的元组
      case (y, 0) => "" + y + "0" // 匹配后一个元素是0的对偶元组
      case (a, b) => "" + a + " " + b
      case _ => "something else" //默认
    }
    println(result)
  }

2.匹配对象

//todo 匹配对象
  //类的构造方法中参数使用var或者val声明
  //这个参数就可以直接作为类的属性使用[圈起来]
  //var参数可以修改的,val参数不可以修改
  class User(val name:String,val age:Int)
  object User{
    def apply(name: String, age: Int): User = new User(name, age)
    def unapply(user: User): Option[(String, Int)] = Option(user.name, user.age)
  }

  val user= User("zhangsan", 30)
  user match{
    case User("张三",30) => println("对象没有问题")
    case _ => println("不匹配")
  }

3.样例类[模式匹配应该学的地方]

/**
 * @author Jinxin Li
 * @create 2020-10-28 18:50
 * 模式匹配
 * 马丁专门为模式匹配的对象匹配创建了特殊的类,样例类,就是在class前增加case关键字
 * 这个类可以当做普通类来用,也能生成特殊类使用
 * 编译器在遍历样例类时,会自动生成伴生对象,apply方法,unapply方法
 * 同时这个类默认实现了可序列化接口
 */
object Match01_match {
  //样例类
  case class User(val name: String, val age: Int)

  def main(args: Array[String]): Unit = {
    val user = User("zhangsan", 30)
    user match {
      case User("张三", 30) => println("对象没有问题")
      case _ => println("不匹配")
    }
  }
}

说明:

样例类就是使用case关键字声明的类

样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，如apply、unapply、toString、equals、hashCode和copy。

样例类是为模式匹配而优化的类，因为其默认提供了unapply方法，因此，样例类可以直接使用模式匹配，而无需自己实现unapply方法。

构造器中的每一个参数都成为val，除非它被显式地声明为var（不建议这样做）

4.变量匹配

object Match01_match {
  def main(args: Array[String]): Unit = {
    val (name, age) = ("zhangsan", 30)
    //1.直接声明对应
    println(name)
    println(age)
    
    //2.map声明,循环匹配
    val map = Map(("a",1),("b",2))
    
    for((k,v) <- map){//打印的时候直接匹配
      println(k + "," + v)
    }

    for((k,2) <- map){//匹配也能做过滤,将v为2的数进行过滤
      println(k)
    }
  }
}

5.匹配函数的参数[要重点学习的地方]

object Match01_match {
  def main(args: Array[String]): Unit = {
    val list = List(("a",1),("b",2),("c",3))
    list.map{case (string,int)=>(string,int*2)}//这里传递出两个参数显然是不合适的
    //注意1.要使用case
    //    2.注意使用花括号
  }
}

5.1 过滤功能

object Match01_match {
    //过滤出第二个数的为奇数
  def main(args: Array[String]): Unit = {
    val list = List(
      ("a",1),("b",1),("c",2)
    )
    list.filter{
      case (_,cont) => {cont%2 ==1}//使用模式匹配
    }
  }
}

6.偏函数

对满足条件的一部分数据处理为偏函数

//一般情况下偏函数就是模式匹配,使用case
object Match01_match {
  //将该List(1,2,3,4,5,6,"test")中的Int类型的元素加一，并去掉字符串。
  def main(args: Array[String]): Unit = {
    val list = List(1,2,3,4,5,6,"test")
    //采集数据,符合条件的数据被采集并做处理,这样的函数称为偏函数
    val result = list.collect{
      case i:Int => i + 1
    }
    println(result)
  }
}