Scala pattern matching

Catalog

One 、 Introduction to pattern matching

1.1 Overview of pattern matching

1.2  Type of pattern matching

Two 、 Pattern matching instance

---

One 、 Introduction to pattern matching

---

1.1 Overview of pattern matching

Scala Provides a powerful pattern matching mechanism , It is also widely used .

A pattern match contains a series of alternatives , Each starts with keywords case. Each alternative contains a pattern and one or more expressions . The arrow symbol => It separates the pattern from the expression .

1.2  Type of pattern matching

Include ：

• Constant mode
• Variable mode
• Constructor mode
• Sequence pattern
• Tuple mode

---

Two 、 Pattern matching instance

---

object Test01 {


  /**
   *  Character constant matching 
   *
   * @param score
   * @param name
   */
  def studentScore02(score: String, name: String) = {
    score match {
      case "A" => println(" good ")
      case "B" => println(" good ")
      case "C" => if (name == "kangll") println("kangll good boy.")
      case _ => {
        if (name == "kangll" && score != "A") {
          println(name + " Work hard , Your grades can be good ！")
        }
      }
    }
  }

  /**
   *  Match database connection information according to keywords （ Constant matching ）
   *
   * @param sparkSession spark Connect 
   * @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 There is a special type of , be called Option.Option There are two kinds of value , One is Some, It's worth it , One is None, No value .
   * Option Usually used in pattern matching , Used to determine whether a variable has a value or no value , This is more than null Come more concise and clear 
   *
   * @param name
   */
  def getGrade(name: String): Unit = {
    val grades: Map[String, String] = Map("kangll" -> "a", "zhangsanfeng" -> "b", "zhangwuji" -> "c")

    // grade  The type of  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")
    }
  }

  /**
   *  Variable matching 
   */
  def variablePatten(x: Any) = {
    x match {
      case x if (x == 5) => x
      case x if (x == "scala") => x
      case _ =>
    }
  }


  /**  Sample class   */
  case class Person(userName: String, age: Int)

  /**
   *  The constructor pattern refers to , Directly in case Statement followed by a class constructor , The matching content is placed in the constructor parameters .
   *
   * @param p
   * @return
   */
  def constructorPattern(p: Person) = {
    p match {
      case Person(userName, age) => "userName = " + userName + ", age = " + age
      case _ => "Other"
    }
  }

  /**
   *  Sequence patterns are used for matching such as arrays Array、 list List、Range Such a set of linear structures , In fact, the principle is also through case class It works .
   *
   * @param p
   */
  def sequencePattern(p: Any) = {
    p match {
      //  Sequence pattern matching ,_* Indicates that the remaining content is matched ,first、second The match array p The first of all 、 Two elements 
      case Array(first, second, _*) => first + ", " + second
      //   _ Configuration set  p The first element of , But not assigned to any variable 
      case List(_, second, _*) => second
      case _ => "Other"
    }
  }

  /**
   *  Variable binding mode 
   *
   * @param t
   */
  def variableBindingPattern(t: Any) = {
    t match {
      // Variable binding , Use variable names （ Here is e）
      // And @ Symbol , If the following pattern matches successfully , Then take the overall matching result as the return value 
      case List(_, [email protected](_, _, _)) => 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))))
  }
}