Scala --- 模式匹配和样例类

Scala的模式匹配机制，可以应用到很多场合：

• switch语句

• 类型查询

• 以及快速获取数据

scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配

匹配字符串：

//todo:匹配字符串 ， 类似 switch
object CaseDemo01 extends App{
  //定义一个数组
  val arr=Array("hadoop","zookeeper","spark","storm")

  //随机取数组中的一位，使用Random.nextInt
  val name = arr(Random.nextInt(arr.length))
  println(name)

  name match {
    case "hadoop"     => println("大数据分布式存储和计算框架...")
    case "zookeeper"  => println("大数据分布式协调服务框架...")
    case "spark"      => println("大数据分布式内存计算框架...")
    //表示以上情况都不满足才会走最后一个
    case _            => println("我不认识你")
  }

}

//输出：
spark
大数据分布式内存计算框架...

匹配类型：

//todo:匹配类型
object CaseDemo02 extends App{
  //定义一个数组
  val arr=Array("hello",1,-2.0,CaseDemo02)

  //随机获取数组中的元素
  val value=arr(Random.nextInt(arr.length))
  println(value)


  value match {
    case x:Int                => println("Int=>"+x)
    case y:Double if(y>=0)    => println("Double=>"+y)
    case z:String             => println("String=>"+z)
    case _                    => throw new Exception("not match exception")
  }

}

//输出：
hello
String=>hello

匹配数组：

//匹配数组
object CaseDemo03 extends App{

  //匹配数组
  val  arr=Array(1,3,5)
  arr match{
    case Array(1,x,y) =>println(x+"---"+y)
    case Array(1,_*)  =>println("1...")
    case Array(0)     =>println("only 0")
    case _            =>println("something else")

  }
}

//输出：
1...

匹配集合：

//匹配集合
object CaseDemo04 extends App{

  val list=List(1,3)
  list match {
    //val list=List(0)
    case 0::Nil        => println("only 0")
    //val list=List(0,3,6)
    case 0::tail       => println("0....")
    //val list=List(1,3,6)
    case x::y::z::Nil  => println(s"x:$x y:$y z:$z")
    //val list=List(1,3)
    case _             => println("something else")
  }
}

匹配元组：

//匹配元组
object CaseDemo05 extends App{

  val tuple=(4,3,5)
  tuple match{
    //val tuple=(1,3,5)
    case (1,x,y)    => println(s"1,$x,$y")
    //val tuple=(2,3,5)
    case (2,x,y)    => println(s"$x,$y")
    //val tuple=(4,3,5)
    case _          => println("others...")
  }
}

样例类：

• 样例类是一种特殊类，它可以用来快速定义一个用于保存数据的类（类似于Java POJO类）
• 而且它会自动生成apply方法，允许我们快速地创建样例类实例对象
• 语法结构： case class 样例类名(成员变量名1:类型1, 成员变量名2:类型2 ...)

// 定义一个样例类
// 样例类有两个成员name、age
case class CasePerson(name:String, age:Int)

// 使用var指定成员变量是可变的
case class CaseStudent(var name:String, var age:Int)

object CaseClassDemo {
  def main(args: Array[String]): Unit = {
    // 1. 使用new创建实例
    val zhagnsan = new CasePerson("张三", 20)
    println(zhagnsan)

    // 2. 使用类名直接创建实例
    val lisi = CasePerson("李四", 21)
    println(lisi)

    // 3. 样例类默认的成员变量都是val的，除非手动指定变量为var类型
    //lisi.age = 22  // 编译错误！age默认为val类型

    val xiaohong = CaseStudent("小红", 23)
    xiaohong.age = 24
    println(xiaohong)
  }
}

//输出：
CasePerson(张三,20)
CasePerson(李四,21)
CaseStudent(小红,24)

样例对象：

• 使用case object可以创建样例对象。样例对象是单例的，而且它没有主构造器。样例对象是可序列化的。
• 格式 ：  case object 样例对象名   case object CheckTimeOutTask

eg：样例类和样例对象结合模式使用 ;  样例类进行模式匹配提取参数

case class SubmitTask(id: String, name: String)
case class HeartBeat(time: Long)
case object CheckTimeOutTask

object CaseDemo06 extends App{

  val arr = Array(CheckTimeOutTask,
    HeartBeat(10000),
    SubmitTask("0001", "task-0001"))

  arr(Random.nextInt(arr.length)) match {

    case SubmitTask(id, name) => println(s"id=$id, name=$name")
    case HeartBeat(time) => println(s"time=$time")
    case CheckTimeOutTask => println("检查超时")
  }
}

//输出： 检查超时

Option类型：

在Scala中Option类型是    样例类来表示可能存在或也可能不存在的值

Option类有2个子类：

• 一个是Some

  • Some包装了某个值

  

• 一个是None

  • None表示没有值

  

object TestOption {
  def main(args: Array[String]) {
    val map = Map("a" -> 1, "b" -> 2)

    val value: Option[Int] = map.get("b")
    val v1 =value match {
      case Some(i) => i
      case None => 0
    }
    println(v1)

    //更好的方式
    val v2 = map.getOrElse("c", 0)
    println(v2)
  }
}

//输出：
2
0

偏函数：

被包在花括号内 ， 没有match的一组case语句 ， 是一个偏函数   ； 偏函数是一个参数和一个返回值的函数

它是PartialFunction[A, B]的一个实例，

• A代表输入参数类型

• B代表返回结果类型  

object TestPartialFunction {
  // func1是一个输入参数为Int类型，返回值为String类型的偏函数
  val func1: PartialFunction[Int, String] = {
    case 1 => "一"
    case 2 => "二"
    case 3 => "三"
    case _ => "其他"
  }

  def main(args: Array[String]): Unit = {
    println(func1(1))

    val list=List(1,2,3,4,5,6)

    //使用偏函数操作
    val result=list.filter{
      case x if x >3 => true
      case _ => false
    }
    println(result)
  }

}

//输出：
一
List(4, 5, 6)