Scala基础 -- 5.模式匹配、样例类、协变逆变非变和上下界

5 模式匹配、样例类、协变逆变非变和上下界

5.1 模式匹配

  Scala有一个十分强大的模式匹配机制，可以应用到很多场合：如switch语句、类型检查等。并且Scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配。

5.1.1 匹配字符串

val arr = Array("hadoop", "storm", "spark", "zookeeper")
val name = arr(Random.nextInt(arr.length))
name match {
    case "hadoop" => println("大数据分布式存储和计算框架")
    case "zookeeper" => println("大数据分布式协调服务框架")
    case "spark" => println("大数据分布式内存计算框架")
    case _ => println("我不认识你...")
}

5.1.2 匹配类型

val arr1 = Array("hello", 1, 2.0, true, ScalaTest5_1)
val r1 = arr1(Random.nextInt(arr1.length))
println(r1)
r1 match {
    case x: Int => print("Int " + x)
    case y: Double if(y >=0 ) => println("Double " + y)
    case z: String => println("String " + z)
    case _ => throw new Exception("not match exception")
}

5.1.3 匹配数组

val arr2 = Array(1, 2, 3)
arr2 match {
    //匹配数组只有三个长度，并且头为1
    case Array(1, x, y) => println(x + ", " + y)
    //匹配数组长度为1，且元素为0
    case Array(0) => println("only 0")
    //匹配数组头为1，长度不限制
    case Array(0, _*) => println("start with 0")
    case _ => println("something else")
}

5.1.4 匹配元组

val tuple = (1,2,3)
tuple match {
    //匹配三个元素的元组，并且第一个元素为1
    case (1, x, y) => println(s"1, $x, $y")
    //匹配三个元素的元组，并且第三个元素为5
    case (_, z, 5) => println(z)
    case _ => println("else")
}

5.1.5 匹配集合

val list = List(1, 2, -1)
list match {
    //匹配长度为1的List，并且元素为0
    case 0 :: Nil => println("only 0")
    //匹配长度为2的List
    case x :: y :: Nil => println(s"x: $x, y: $y")
    //匹配头为0，长度不限制的List
    case 0 :: tail => println("start with 0")
    case _ => println("something else")
}

5.2 样例类和Option类型

object ScalaTest5_2{
    /**
      * 在Scala中样例类是一种特殊的类，可用于模式匹配。定义形式：
      * case class 类型，是多例的，后面要跟构造参数。
      * case object 类型，是单例的。
      */
    def main(args: Array[String]): Unit = {
        val arr = Array(CheckTimeOut, HeartBeat(1000), SubmitTask("11", "task-1"))
        arr(Random.nextInt(arr.length)) match {
            case SubmitTask(id: String, name: String) => println(s"id: $id, name: $name")
            case HeartBeat(time: Long) => println(s"time: $time")
            case CheckTimeOut => println("CheckTimeOut")
            case _ => println("something else")
        }

        /**
          * 在Scala中Option类型用样例类来表示可能存在或者可能不存在的值(Option的子类有Some和None)。
          * Some包装了某个值，None表示没有值
          */
        val map = Map("a" -> 1, "b" -> 2)
        val v = map.get("c") match {
            case Some(i) => i
            case None => 0
        }
        println(v)
        //也可以
        println(map.getOrElse("c", 0))
    }
}
case class SubmitTask(id: String, name: String)
case class HeartBeat(time: Long)
case object CheckTimeOut

5.3 偏函数

/**
  * 被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A, B]的一个实例
  * A代表输入参数类型，B代表返回结果类型，常用作输入模式匹配
  * 偏函数最大的特点就是它只接受和处理其参数定义域的一个子集
  */
//偏函数必须指定PartialFunction，并且参数给定输入和输出类型
def fun1: PartialFunction[String, Int] = {
    case "one" => 1
    case "two" => 2
    case _ => -1
}
//fun2是普通方法模拟偏函数
def fun2(num: String) : Int = num match {
    case "one" => 1
    case "two" => 2
    case _ => -1
}
def main(args: Array[String]): Unit = {
    println(fun1("two"))
    println(fun2("one"))
}

5.4 协变、逆变、非变

  协变和逆变主要是用来解决参数化类型的泛化问题。Scala的协变与逆变是非常有特色的，完全解决了Java中泛型的一大缺憾；举例来说，Java中，如果有 A是 B的子类，但 Card[A] 却不是 Card[B] 的子类；而 Scala 中，只要灵活使用协变与逆变，就可以解决此类 Java 泛型问题；
  由于参数化类型的参数（参数类型）是可变的，当两个参数化类型的参数是继承关系（可泛化），那被参数化的类型是否也可以泛化呢？Java中这种情况下是不可泛化的，然而Scala提供了三个选择，即协变(“+”)、逆变（“-”）和非变。
下面说一下三种情况的含义，首先假设有参数化特征Queue，那它可以有如下三种定义。
(1) trait Queue[T] {}
  这是非变情况。这种情况下，当类型B是类型A的子类型，则Queue[B]与Queue[A]没有任何从属关系，这种情况是和Java一样的。
(2) trait Queue[+T] {}
  这是协变情况。这种情况下，当类型B是类型A的子类型，则Queue[B]也可以认为是Queue[A]的子类型，即Queue[B]可以泛化为Queue[A]。也就是被参数化类型的泛化方向与参数类型的方向是一致的，所以称为协变。
(3) trait Queue[-T] {}
  这是逆变情况。这种情况下，当类型B是类型A的子类型，则Queue[A]反过来可以认为是Queue[B]的子类型。也就是被参数化类型的泛化方向与参数类型的方向是相反的，所以称为逆变。

C[+T]：如果A是B的子类，那么C[A]是C[B]的子类。
C[-T]：如果A是B的子类，那么C[B]是C[A]的子类。
C[T]： 无论A和B是什么关系，C[A]和C[B]没有从属关系。

object ScalaTest5_4{
    def main(args: Array[String]): Unit = {
        //支持协变 Temp1[Sub]还是Temp1[Super]的子类
        val t1: Temp1[Super] = new Temp1[Sub]("Hello World")
        println(t1.toString)

        //支持逆变 Temp1[Super]是Temp1[Sub]的子类
        val t2: Temp2[Sub] = new Temp2[Super]("Hello World")
        println(t2.toString)

        //支持非变 Temp3[Super]与Temp3[Sub]没有从属关系，如下代码会报错
//        val t3: Temp3[Super] = new Temp3[Sub]("Hello World")
//        val t4: Temp3[Sub] = new Temp3[Super]("Hello World")
    }
}
class Super
class Sub extends Super
//协变
class Temp1[+A](title: String)
//逆变
class Temp2[-A](title: String)
//非变
class Temp3[A](title: String)

5.5 上、下界

  在指定泛型类型时，有时需要界定泛型类型的范围，而不是接收任意类型。比如，要求某个泛型类型，必须是某个类的子类，这样在程序中就可以放心的调用父类的方法，程序才能正常的使用与运行。此时，就可以使用上下边界Bounds的特性；
  Scala的上下边界特性允许泛型类型是某个类的子类，或者是某个类的父类；
(1) U >: T
  定义类型下界，也就是U必须是类型T的父类(或本身，自己也可以认为是自己的父类)。
(2) S <: T
  定义类型上界，也就是S必须是类型T的子类（或本身，自己也可以认为是自己的子类)。