基础语法

/*
模式匹配的语法:
变量 match {
case 匹配条件 => {
….
}
case 匹配条件 => {
…
}
….
case x => xx // 类似java withch的default，也可以写成：case _ => xx
}
模式匹配中如果条件匹配上之后会执行=>后面的内容,执行完成之后自动退出,不会继续执行后续的case条件
模式匹配有返回值的,返回值是满足条件的分支的块表达式的结果值
/

package tcode.chapter08
import scala.io.StdIn
object $01_MatchDefined {
  def main(args: Array[String]): Unit = {
    val line = StdIn.readLine("请输入一个单词:")
    val r = line match {
      case "hadoop" =>
        var a = 10
        var b = 20
        var c = a+b
        println("输入是hadoop")
        10
      case "spark" =>{
        println("输入是spark")
        20
      }
      case "flume"=>{
        println("输入是flume")
        30
      }
      //case x => println(s"其他...${x}")
        //如果x在右边没有使用可以用_代替
        //相当于java switch的default
      case _ =>
        println(s"其他...")
        40
    }
    println(r)
  }
}

模式守卫

package tcode.chapter08
import scala.io.StdIn
object $02_MatchIf {
  /**
    * 模式匹配守卫语法：
    *     变量 match {
    *       case 条件 if(布尔表达式)  => {...}
    *       case 条件 if(布尔表达式)  => {...}
    *       case 条件 if(布尔表达式)  => {...}
    *     }
    * 模式匹配守卫必须满足条件以及if判断语句才算匹配上
    */
  def main(args: Array[String]): Unit = {
    val line = StdIn.readLine("请输入一句话:")
    line match {
      case x if(x.contains("spark")) => println("句子中包含spark")
      case x if(x.contains("hadoop")) => println("句子中包含hadoop")
      case x if(x.contains("hello")) => println("句子中包含hello")
      case x => println("其他情况...") // 类似java withch的default
    }
  }
}

模式匹配类型

模式匹配值

模式匹配在匹配值的时候,如果匹配条件是要使用外部变量的值,此时变量名必须首字母大写

package tcode.chapter08
import scala.io.StdIn
import scala.util.Random
object $03_MatchValue {
  //模式匹配在匹配值的时候,如果匹配条件是要使用外部变量的值,此时变量名必须首字母大写
  def main(args: Array[String]): Unit = {
    val arr = Array("hello",2.0,false,10,"hadoop")
    val index = Random.nextInt( arr.size )
    val data = arr(index)
    println(data)
    val Wc = "hadoop"
    data match {
      case Wc => println("hadooop............")
      case "hello" => println("hello............")
      case 2.0 => println("2.0............")
      case false => println("false............")
      case x => println("其他情况............")
    }
  }
}

模式匹配类型

package tcode.chapter08
import scala.util.Random
object $04_MatchType {
class Person(val name:String,var age:Int)
  /**
    * 匹配类型:
    *   变量 match {
    *     case x:类型1 => ..
    *     case x:类型2 => ..
    *   }
    */
  def main(args: Array[String]): Unit = {
    val arr = Array("hello",2.0,false,10,"hadoop",new Person("lisi",30),new Person("wangwu",20))
    val index = Random.nextInt( arr.size )
    val data = arr(index)
    println(data)
    data match{
      case x:String => println("数据是字符串")
      case x:Int => println("数据是Int")
      case x:Double => println("数据是Double")
      case x:Boolean => println("数据是Boolean")
      case x:Person if(x.name=="lisi")=> println("数据是Person lisi")
      case x:Person if(x.name=="wangwu")=> println("数据是Person wangwu")
    }
  }
}

模式匹配数组

package tcode.chapter08
object $05_MatchArray {
  def main(args: Array[String]): Unit = {
    val arr = Array[Int](1,2,3)
    arr match {
      case Array(x) => println("匹配数组只有一个元素")
      case Array(_:Int,_:Int,_:Int) => println("匹配数组有三个元素") // x,y,z如果在右边不使用可以用_简化
      case Array(x,y,z,_*) => println("匹配数组至少有三个元素")
    }
  }
}

模式匹配list

package tcode.chapter08
object $06_MatchList {
  def main(args: Array[String]): Unit = {
    val arr = List[Int](1,2,3)
// 第一种方式
    arr match {
      case List(x) => println("匹配List只有一个元素")
      case List(x:Int,_*) => println("匹配List至少有一个元素") // x,y,z如果在右边不使用可以用_简化
      case List(_,y,_) => println("匹配List有三个元素")
    }
// 第二种方式
    arr match {
      case x :: Nil =>  println("匹配List只有一个元素")
      case (x:Int) :: y :: tail =>  println(s"匹配List至少有一个元素 ${x} ${y}  ${tail}")
      case x :: y :: z :: Nil =>  println("匹配List有三个元素")
    }
  }
}

模式匹配元祖

package tcode.chapter08
object $07_MatchTuple {
  //匹配元组的时候,变量是几元元组那么匹配条件就应该是几元元组
  def main(args: Array[String]): Unit = {
    val t1:(Any,Any,Any) = ("zhangsan",20,"shenzhen")
    t1 match{
      case (name:String,age,address) => println(s"${name} ${age} ${address}")
    }
// 嵌套
    val ts = List[(String,(String,(String,(String,Int))))](
      ("宝安区",("宝安中学",("大数据班",("zhangsan",20)))),
      ("宝安区",("宝安中学",("大数据班",("wangwu",20)))),
      ("宝安区",("宝安中学",("大数据班",("zhaoliu",20))))
    )
    ts.foreach(x=> {
      x match {
        case (regionName,(schoolName,(className,(stuName,age)))) => println(stuName)
      }
    })
  }
}

匹配样例类

/*
样例类语法: case class 类名([val/var] 属性名:类型)
1)样例类,自动生成了伴生对象，并且伴生对象中自动提供了一些常用的方法，
如apply、unapply、toString、equals、hashCode和copy。
2)样例类是为模式匹配而优化的类，因为其默认提供了unapply方法，
因此，样例类可以直接使用模式匹配，而无需自己实现unapply方法。
3)创建样例类对象: 样例类类名(属性值,..)
4)样例类属性如果不用val/var修饰,默认就是val修饰

*/

package tcode.chapter08
object $08_MatchClass {
  case class Person(val name:String ,var age:Int, address:String)
  def main(args: Array[String]): Unit = {
    val person = Person("zhangsan",20,"beijing")
    val student = Student("zhangsan",20,"beijing")
    println(person.name)
    println(person.age)
    println(person.address)
    person match {
      case Person(x,y,z) => println(s"x=${x} y=${y} z=${z}")
    }
    student match{
      case Student(x,y,z) =>  println(s"x=${x} y=${y} z=${z}")
    }
  }
}
class Student(val name:String ,var age:Int, val address:String)
// 伴生对象
object Student{
  def apply(name: String, age: Int, address: String): Student = new Student(name, age, address)
  def unapply(arg: Student): Option[(String, Int, String)] = {
    if(arg==null)
        None
    else
      Some((arg.name,arg.age,arg.address))
  }
}

变量声明中的模式匹配

for循环的模式匹配

package tcode.chapter08
object $09_MatchParamDefined {
  def main(args: Array[String]): Unit = {
    val t = ("zhangsan",20,"shenzhen")
---------------元祖
    println(t._1)
    val (name,age,address) = ("zhangsan",20,"shenzhen")
    println(name)
    println(age)
    println(address)
---------------数组
    val Array(x,_) = Array(10,2)
    val y :: Nil  = List(10)
    println(y)
----------------for循环
    val map = Map[String,Int]("aa"->10,"bb"->20)
    for((key,value) <- map){
      println(key)
      println(value)
    }
------------
  }
}

偏函数中的模式匹配

偏函数不需要x=>!!!

package tcode.chapter08
import scala.util.Random
object $10_PartialFunction {
  /**
    * 偏函数: 没有match关键字的模式匹配称之为偏函数
    * 语法:
    *   val 函数名:PartialFunction[IN,OUT] = {
    *     case 条件 => ...
    *     case 条件 => ...
    *     case 条件 => ...
    *   }
    *   IN: 代表函数的参数类型
    *   OUT: 代表函数返回值类型
    *
    */
  def main(args: Array[String]): Unit = {
    val arr  = Array("hello",10.0,22,false)
    val data = arr(Random.nextInt(arr.length))
    println(data)
/*    val func:String=>Unit = (x:String) => {
      case "hello" => println(".....")
      case "lisi" => println("+++++++")
      case _ => println("-------------")
    }*/
    val func:PartialFunction[Any,Unit] = {
      case "hello" => println("hello.......")
      case 10.0 => println("10.0.......")
      case 22 => println("22.......")
      case false => println("false.......")
    }
    func(data)
    val ts = List[(String,(String,(String,(String,Int))))](
      ("宝安区",("宝安中学",("大数据班",("zhangsan",20)))),
      ("宝安区",("宝安中学",("大数据班",("wangwu",20)))),
      ("宝安区",("宝安中学",("大数据班",("zhaoliu",20))))
    )
    val func2:PartialFunction[(String,(String,(String,(String,Int)))),(String,String)] = {
      case (regionName,(schoolName,(className,(stuName,age)))) => (schoolName,className)
    }
    ts.map(func2).foreach(x=>println(x))
    // 工作中的应用：
    //直接传递函数值
    ts.map{
      case (regionName,(schoolName,(className,(stuName,age)))) => (schoolName,stuName)
    }.foreach{
      case (schoolName,stuName) => println(stuName)
    }
  }
}