【Scala快速入门】--模式匹配

Scala模式匹配

模式匹配：内容匹配

模式匹配的功能

• 类似于Java中的switch case，对代码中的内容进行判断，根据判断匹配对应的结果

• 但是功能比Java中的switch case的功能更加强大，可以匹配内容、类型等多种条件

• Java中的switch case的语法

  switch (变量) {
  	case value1：
  			op1
  			break;
  	case value2
  			op2
  			break;
  			
  	……
  	default opN;
  }
  

  package bigdata.itcast.cn.java.swithCaseDemo;
  
  import java.util.Scanner;
  
  /**
   * @ClassName SwitchDemo
   * @Description TODO 测试 Java 中的 switch  case
   * @Date 2021/4/13 12:51
   * @Create By     Frank
   */
  public class SwitchDemo {
      public static void main(String[] args) {
          System.out.println("问：你正在打游戏，队友正喊你团一波，这时候你女朋友掉水里的，请问你怎么选？");
          System.out.println("    A：继续跟团，不能坑队友");
          System.out.println("    B：救女朋友，对象不好找");
          System.out.println("    C：不选择，换个游戏也换个女朋友");
          System.out.print("请输入你的选项【A/B/C】：");
          //构建输入器
          Scanner scanner = new Scanner(System.in);
          //读取用户输入
          String input = scanner.next();
          //判断输入
          switch (input){
              case "A":
                  System.out.println("U r a bad man");
                  break;
              case "B":
                  System.out.println("U r a good man");
                  break;
              case "C":
                  System.out.println("U r a not man");
                  break;
              default:
                  System.out.println("U hava no choice");
          }
  
  
      }
  }
  

模式匹配的语法

• 功能比switch case功能要强大，当做switch case来使用
• 语法：match case

变量 match {
	case value1 => operater1
	case value2 => operater2
	……
	case valueN => operaterN
	[case _ => default Operator]
}

匹配内容实现

object MatchCaseDemo1 {
  def main(args: Array[String]): Unit = {
    //输出问题
    println("问：你正在打游戏，队友正喊你团一波，这时候你女朋友掉水里的，请问你怎么选？");
    println("    A：继续跟团，不能坑队友");
    println("    B：救女朋友，对象不好找");
    println("    C：不选择，换个游戏也换个女朋友");
    print("请输入你的选项【A/B/C】：");
    //读取用户输入
    val input = StdIn.readLine()
    //匹配input的值
    input match {
      case "A" => println("U r a bad man")
      case "B" => println("U r a good man")
      case "C" => println("U r a not man")
      case _ => println("U have not a choice")
    }
  }
}

• 与Java中switchcase的区别
• match case可以实现匹配内容，但不局限于匹配内容
  • 每个case中，没有break，一旦匹配成功，自动跳出
  • 没有default选项，一般通过 _ 来表示任意内容，代替default，下划线放到最后

模式匹配：类型匹配及守卫条件

模式匹配类型实现

• 功能：判断变量的类型，根据不同类型实现不同的操作

• 应用：一般用于实现异常捕获

  object MatchCaseDemo2 {
    def main(args: Array[String]): Unit = {
      //定义一个数组
      val arr = Array(1,2,true,14.98,"itcast")
      //取出元素，输出对应的元素的值和类型
      val input = arr(Random.nextInt(arr.length))
      input match{
        case x:Int => println(s"type:Int，value:${x}")
        case y:Double => println(s"type:Double，value:${y}")
        case m:String => println(s"type:String，value:${m}")
        case n:Boolean => println(s"type:Boolean，value:${n}")
        case _ => println("这是其他类型")
      }
    }
  }
  

守卫条件的实现

• 在匹配时，可以指定匹配条件，如果不满足匹配的守卫条件，依旧不会匹配成功

  object MatchCaseDemo2 {
    def main(args: Array[String]): Unit = {
      //定义一个数组
      val arr = Array(1,2,true,14.98,"itcast")
      //取出元素，输出对应的元素的值和类型
      val input = arr(0)
      input match{
        case x:Int if (x > 1) => println(s"type:Int，value:${x}")
        case y:Double => println(s"type:Double，value:${y}")
        case m:String => println(s"type:String，value:${m}")
        case n:Boolean => println(s"type:Boolean，value:${n}")
        case _ => println("这是其他类型")
      }
    }
  }
  

模式匹配：数组、集合、元组匹配

• 模拟匹配数组

  object MatchCaseDemo3 {
    def main(args: Array[String]): Unit = {
      //定义一个数组
      val arr: Array[Int] = Array(1,4,7)
      //匹配数组
      arr match{
        case Array(0) => println(s"这个数组中只有一个元素，为0")
        case Array(1,2,3) => println(s"这个数组中有三个个元素，为1,2,3")
        case Array(1,x,y) => println(s"这个数组中有三个个元素,第一个元素肯定为1")
        case Array(0,_*) => println(s"这个数组中有多个元素，第一个元素肯定是0")
        case _ => println("这是其他类型数组")
      }
    }
  }
  

• 模式匹配集合

  object MatchCaseDemo3 {
    def main(args: Array[String]): Unit = {
      //定义一个数组
      val list = List(1,2)
      //匹配数组
      list match{
        case List(1,2) => println(s"只有两个元素，为1,2")
        case x::y::Nil => println(s"只有两个元素，元素值任意")
        case 1::Nil => println(s"只有1个元素，元素值1")
        case 1::tail => println(s"第一个元素是1，其他的元素是任意的")
        case _ => println("这是其他类型")
      }
    }
  }
  

• 模式匹配元组

  object MatchCaseDemo3 {
    def main(args: Array[String]): Unit = {
      //定义一个数组
      val tuple = (3,3,3)
      //匹配数组
      tuple match{
        case (1,2,x) => println(s"元素的值为1,2和任意一个")
        case (x,3,z) => println(s"第二个元素值必须为3")
        case (x,y,z)=> println(s"元素值任意")
        case _ => println("这是其他类型")
      }
    }
  }
  

模式匹配：声明变量匹配取值

数据处理时的常见问题

• 如果有一个Array数组，总共4个元素，我们需要取出数组中的每个元素，单独处理，怎么取？

  val array = Array(100,20,40,30) //sum,avg,max,min
  

  sum = array(0)
  avg = array(1)
  max = array(2)
  min = array(3)
  for(i <- array)
  

• 如果有一个List集合，每个元素都由4个字段构成，我想取出每个元素中的第二列和第三列，怎么取？

  val list = List("1 zhangsan 18 male","2 lisi 20 female","3 wangwu 22 male")
  

  list.map(line => {
     val arr = line.split(" ")
     val name = arr(1)
     val age = arr(2)
     (name,age)
  })
  

• 如果有一个Map集合，每个元素的Value是二元组类型，格式为：(id,(name,age)) 要取出三列，怎么取？

  val map = Map((1,("zhangsan",18)),(2,("lisi",20)),(3,("wangwu",22)))
  

  map.foreach(tuple => {
  	val id = tuple._1
  	val name = tuple._2._1
  	val age = tuple._2._2
  	println(id+"\t"+name+"\t"+age)
  })
  

声明变量取值的设计

• 可以通过申明变量的形式与数据进行匹配，将匹配的结果直接赋值给对应的变量

声明变量取值的实现

• 如果有一个Array数组，总共4个元素，我们需要取出数组中的每个元素，单独处理，怎么取？

  val array = Array(100,20,40,30)
  

  val Array(sum,avg,max,min) = array
  

• 如果有一个List集合，每个元素都由4个字段构成，我想取出每个元素中的第二列和第三列，怎么取？

  val list = List("1 zhangsan 18 male","2 lisi 20 female","3 wangwu 22 male")
  

  list.map(line => {
     val Array(_,name,age,_) = line.split(" ")
   (name,age)
  })
  

• 如果有一个Map集合，每个元素的Value是二元组类型，格式为：(id,(name,age)) 要取出三列，怎么取？

  val map = Map((1,("zhangsan",18)),(2,("lisi",20)),(3,("wangwu",22)))
  

  map.foreach{
  	case (id,(name,age)) => println(id+"\t"+name+"\t"+age)
  }
  

点个赞嘛！