Scala快速入门--模式匹配

Posted 一只楠喃

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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)
}

点个赞嘛！
在这里插入图片描述

以上是关于Scala快速入门--模式匹配的主要内容，如果未能解决你的问题，请参考以下文章

第26讲: Scala中的模式匹配入门实战详解

Scala入门到精通——第十五节 Case Class与模式匹配

Scala快速入门--正则对象

Scala笔记--模式匹配

Scala笔记--模式匹配

2021年大数据常用语言Scala（三十三）：scala高级用法 模式匹配