Scala学习笔记------模式匹配，样例类，偏函数

scala学习笔记------模式匹配，样例类，偏函数

一. 模式匹配

一个模式匹配包含了一系列备选项，每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。

匹配规则：

1. case_ 什么都匹配，放在最后
2. match可以匹配值也可以匹配类型
3. 匹配过程中有数值的转换
4. 从上往下匹配，匹配到后不在向下匹配

object Match {
  def MatchTest(o:Any): Unit ={
    o match{
      case 1 =>println("value is 1")
      case i:Int =>println(s"type is Int,value =$i")
      case d:Double =>println(s"type is Double,value =$d")
      case s:String =>println(s"type is String,value =$s")
      case c:Char=>println(s"value is Char,value is $c")
      case _ =>println("no match")//_匹配任何，类似于java的default
    }
  }
  def main(args: Array[String]): Unit = {
  //1.0先数值转换为1，所以先匹配上值1，不匹配int
    val tp =(1,1.0,1.2,"abc",'a',true)
    val iter:Iterator[Any]=tp.productIterator
    iter.foreach(s=>{MatchTest(s)})
  }
}

output:
value is 1
value is 1
type is Double,value =1.2
type is String,value =abc
value is Char,value is a
no match

二. 样例类

使用了case关键字的类定义就是就是样例类(case classes)，样例类是种特殊的类，经过优化以用于模式匹配。样例类可以new也可以不new

在声明样例类时，下面的过程自动发生了：

1. 构造器的每个参数都成为val，除非显式被声明为var，但是并不推荐这么做；
2. 实现了类构造参数的getter方法，当构造参数是var类型，它就帮你实现setter和getter方法
3. 在伴生对象中提供了apply方法，所以可以不使用new关键字就可构建对象；
4. 提供unapply方法使模式匹配可以工作；
5. 生成toString、equals、hashCode和copy方法，除非显示给出这些方法的定义。

object Test {
   def main(args: Array[String]) {
        val alice = new Person("Alice", 25)
        val bob = new Person("Bob", 32)
        val charlie = new Person("Charlie", 32)
   
    for (person <- List(alice, bob, charlie)) {
        person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) =>
               println("Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   // 样例类
   case class Person(name: String, age: Int)
}

output:
Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?

三.偏函数

如果一个方法中没有match只有case，这个函数可以定义成PartialFunction偏函数。偏函数定义时，不能使用括号传参，默认PartialFunction中传入一个值，匹配上了对应的case，返回一个值
偏函数相当于java中的switch…case,只能匹配一种类型
PartialFunction[匹配的类型,匹配返回的类型]

object PartialFunction {
  //偏函数，只能匹配一个值，匹配上了返回某个值
  def Mytest:PartialFunction[String,Int]={
    case "abc"=>2
    case "a"=>1
    case _ =>200
  }

  def main(args: Array[String]): Unit = {
    val result:Int=Mytest("abc")
    println(result)//输出2
  }
}