一、模式匹配介绍

---

1.1模式匹配概述

Scala 提供了强大的模式匹配机制，应用也非常广泛。

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

1.2 模式匹配的类型

包括：

• 常量模式
• 变量模式
• 构造器模式
• 序列模式
• 元组模式

---

二、模式匹配实例

---

object Test01 {


  /**
   * 字符常量匹配
   *
   * @param score
   * @param name
   */
  def studentScore02(score: String, name: String) = {
    score match {
      case "A" => println("优秀")
      case "B" => println("良好")
      case "C" => if (name == "kangll") println("kangll good boy.")
      case _ => {
        if (name == "kangll" && score != "A") {
          println(name + "要努力呀，你的成绩才能好！")
        }
      }
    }
  }

  /**
   * 根据关键字匹配数据库连接信息（常量匹配）
   *
   * @param sparkSession spark连接
   * @param dbSourceType
   * @param tableName
   */
  def getMySQLDataConnByTableName(sparkSession: SparkSession, dbSourceType: String, tableName: String) = {

    dbSourceType.toLowerCase match {
       case "calc" => MysqlJdbcUil.getDataBySql(sparkSession, calcMySQLURL, calcMySQLUSER, calcMYSQLPWD, tableName)
       case "ddqs" => MysqlJdbcUil.getDataBySql(sparkSession, calcMySQLURL, calcMySQLUSER, calcMYSQLPWD, tableName)
       case "ress" => MysqlJdbcUil.getDataBySql(sparkSession, calcMySQLURL, calcMySQLUSER, calcMYSQLPWD, tableName) 
      case _ => null
    }
  }


  /**
   * Scala有一种特殊的类型，叫做Option。Option有两种值，一种是Some，表示有值，一种是None，表示没有值。
   * Option通常会用于模式匹配中，用于判断某个变量是有值还是没有值，这比null来的更加简洁明了
   *
   * @param name
   */
  def getGrade(name: String): Unit = {
    val grades: Map[String, String] = Map("kangll" -> "a", "zhangsanfeng" -> "b", "zhangwuji" -> "c")

    // grade 的类型为 Option
    val grade: Option[String] = grades.get(name)
    grade match {
      case Some(grade) => println("your grade is " + grade)
      case None => println("Sorry, your grade is not in this system")
    }
  }

  /**
   * 变量匹配
   */
  def variablePatten(x: Any) = {
    x match {
      case x if (x == 5) => x
      case x if (x == "scala") => x
      case _ =>
    }
  }


  /** 样例类  */
  case class Person(userName: String, age: Int)

  /**
   * 构造器模式指的是，直接在case语句后面接类构造器，匹配的内容放置在构造器参数中。
   *
   * @param p
   * @return
   */
  def constructorPattern(p: Person) = {
    p match {
      case Person(userName, age) => "userName = " + userName + ", age = " + age
      case _ => "Other"
    }
  }

  /**
   * 序列模式用于匹配如数组Array、列表List、Range这样的线性结构集合，其实原理也是通过case class起作用的。
   *
   * @param p
   */
  def sequencePattern(p: Any) = {
    p match {
      // 序列模式匹配，_*表示匹配剩余内容，first、second匹配数组p中的第一、二个元素
      case Array(first, second, _*) => first + ", " + second
      //   _配置集合 p的第一个元素，但不赋给任何变量
      case List(_, second, _*) => second
      case _ => "Other"
    }
  }

  /**
   * 变量绑定模式
   *
   * @param t
   */
  def variableBindingPattern(t: Any) = {
    t match {
      //变量绑定，采用变量名（这里是e）
      //与@符号，如果后面的模式匹配成功，则将整体匹配结果作为返回值
      case List(_, e@List(_, _, _)) => e
      case _ => Nil
    }
  }


  def main(args: Array[String]): Unit = {
    this.studentScore02("C", "kangll")
    getGrade("kangll")
    getGrade("long")
    constructorPattern(new Person("kangll", 20))
    println(this.sequencePattern(List("spark", "Hive", "SparkSQL")))
    println(this.sequencePattern(Array("SparkR", "Spark Streaming", "Spark MLib")))
    println(this.variableBindingPattern(List(List(1, 2, 3), List(2, 3, 4))))
  }
}