Scala之模式匹配

最新推荐文章于 2024-11-04 16:33:25 发布
最新推荐文章于 2024-11-04 16:33:25 发布
阅读量94 收藏
点赞数
分类专栏： 大数据学习 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45481968/article/details/108332191
版权

1.模式匹配基本语法

/**变量 match {
           case 值 =>
              匹配后的逻辑
           case 值 =>
              匹配后的逻辑
        }
*/
import scala.io.StdIn

object $01_MatchBasic {        
    
  def main(args: Array[String]): Unit = {

    val x = StdIn.readLine()

    x match {
      case "spark" =>
        println("输入的是spark")
      case "hadoop" =>
        println("输入的是hadoop")
      case "flume" =>
        println("============")
        println("输入的是flume")

      //case x =>
      //  println(s"输入的是${x}")
      //如果变量不需要在右边使用，则可以用_代替
      case _ =>
       println(s"输入的是其他字符串")
    }
  }
}

2.模式守卫

匹配某个范围的数据，可在模式匹配中增加守卫条件

import scala.io.StdIn
object $02_MatchGuard {

  /**
    * 守卫
    * 模式匹配语法:
    *    变量 match {
    *       case 值 if 布尔表达式 =>
    *          匹配后的逻辑
    *       case 值  if 布尔表达式  =>
    *          匹配后的逻辑
    *    }
    *
    * 模式匹配有返回值
    */
  def main(args: Array[String]): Unit = {

    val line = StdIn.readLine()

    val result = line match  {
        
      case x if x.contains("hello") => {
        println(s"${x} 包含hello")
        10
      }
      case x if x.contains("spark") =>
        println(s"${x} 包含spark")
        20
      case x =>
        println("其他字符串")
        30
    }

    println(result)
  }
}

//输出结果
//请输入字符串
//helloworld
//helloworld包含hello
//10

3.模式匹配类型

3.1常量匹配

scala中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等。

object TestMatchVal {

  def main(args: Array[String]): Unit = {
    println(describe(6))

  }
  def describe(x: Any) = x match {

    case 5 => "Int five"

    case "hello" => "String hello"

    case true => "Boolean true"

    case '+' => "Char +"
      
	case _=>"your input is wrong"
  }

}

	//打印结果
	//your input is wrong
3.2 类型匹配
import scala.io.StdIn
import scala.util.Random

object $03_MatchValue {
  def main(args: Array[String]): Unit = {
    val list=List[Any]("hello",10,false,2.2,100)
    val value:Any=list(Random.nextInt(list.length))
    println(value)
   /* value match {
      case x:String => println(s"字符串${x}")
      case _:Double => println("double")
      case _:Boolean => println("boolean")
      case _:Int => println("int")
      case _ => println("其他类型")
    }*/
    //***匹配的时候 如果匹配条件中是通过变量匹配***
    //    1、如果变量名首字母是小写，则普通变量，后续值会传递给变量
     //			即若变量名为abc，输入hello后hello赋值给abc，打印==========hello
    //    2、如果变量名首字母是大写，则匹配外部的常量，相当于就是匹配一个具体的值
     // 		即若变量名为Abc，输入hello后，与Abc的值"hello spark"不匹配，打印*********	
    val Abc="hello spark"
    println("请输入")
    val line=StdIn.readLine()
    line match{
      case Abc if Abc.contains("hello")=>{
      println("=========="+Abc)
    }
      case _=>println("************")
    }
    val aaa:Int=10

  }
}

    //打印结果
	//false
	//boolean
	//请输入
	//hello abc
	//************
3.5 匹配数组
object $04_MatchArray {

  def main(args: Array[String]): Unit = {

    //val arr = Array[Any] (10,20,30,40)
    val arr = Array[Any] (30,"hello",2.2,40)

    arr match {
        //匹配数组有三个元素
      case Array(x,y,z) =>
        println(s"数组有三个元素，${x} ${y} ${z}")
        //匹配数组首位元素
      case Array(10,_*) =>
        println("数组首位元素是10，后面的元素不清楚")
      case Array(x:Int,y:String,z:Double,_*) =>
        println("数组至少有三个元素，分为为int string double类型")
    }


    /**
      * Array[Int] => new Int[]{..}
      * Array[Stirng] => new String[]{}
      * arr = new Object[]{}
      *
      * new String[]{}
      */
    arr match {
      case x:Array[Any] => println("Array[Any]")
    }
  }
}

	//打印结果
	//数组最少有三个元素，分别为int string double类型
	//Array[Any]
3.6 匹配列表
import scala.collection.immutable.Queue

object $05_MatchList {

  def main(args: Array[String]): Unit = {

    val list = List("hello",false,2.2,10,30,"hadoop")

/*    list match {
      case List(x) => println("匹配list只有一个元素，${x}")
      case List(x:String,_:Boolean,_*) => println("匹配list至少有两个元素,这两个元素的类型为string boolean")
      case List(x,y,z,_*) => println(s"匹配list至少有三个元素 ${x} ${y} ${z}")
      case _ => println("其他")
    }*/
    var n:List[Any] = Nil
    n = list
    val list2 = 0 :: 10 :: Nil
    println(list2)
//打印结果
//List(0, 10)

    //val A = List(10,30,"hadoop")

      
      
      
    list match{
      case x :: Nil => println("匹配list只有一个元素，${x}")

      case (x:String) :: (y:Int) :: tail  => println(s"匹配至少两个元素，元素类型分别为 string boolean ${tail}")

      case x :: y :: z :: abc => println(s"匹配list至少有三个元素 ${x} ${y} ${z} ${abc}")
    }
      //打印结果 匹配至少两个元素，元素类型分别为 string boolean ${tail}

      
      
      
    /**
      * 泛型的特性:  泛型擦除
      * List[Int] -> new List
      *
      */
    list match {
      case x:List[Int] => println("List[Int]")
      case x:List[String] => println("List[String]")
      case x:List[Any] => println("List[Any]")
    }
	//打印结果	List[Int]
      
      
      
      
    val map = Map[String,String]("aa"->"bb")

    map match {
      case x:Map[String,Int] => println("Map[Int,Int]")
    }
	//打印结果 Map[Int,Int]
      
      
      
      
    val set = Queue[Any](1,2,3)

    set match {
      case x:Queue[Int] => println("set[String]")
    }
  }
}
//打印结果 set[String]
3.7 匹配元组
object $06_MathType {

  def main(args: Array[String]): Unit = {

    val tuple:(Any,Any,Any) = ("zhangsan",20,"北京")

    tuple match {
      case (name:String,_:Int,_:String) =>
        println(s"${name} string")
      case (name,_,_) =>
        println(s"name=${name}")
    }
	//打印结果
      //zhangsan String
      
      
      
    val school = List(
      ("北京小学",("小学一班",("1001","zhangsan",20))),
      ("北京小学",("小学一班",("1002","lisi",22))),
      ("北京小学",("小学一班",("1003","wangwu",23)))
    )

    //取出学生的姓名
    //val result = school.map(_._2._2._2)
    //val reuslt = school.map( line => {
    //  line match {
    //    case(schoolName,(className,(sid,sname,age))) => sname
    //  }
    //})
    //
    val reuslt = school.map {
      case (schoolName,(className,(sid,sname,age))) => sname
    }
    println(reuslt)

  }
}
//打印结果
//List(zhangsan, lisi, wangwu)
3.8 匹配对象及样例类
import scala.beans.BeanProperty

object $07_MathObect {

  case class Person(@BeanProperty name:String, @BeanProperty age:Int)

  trait SEX

  case object Man extends SEX
  case object Woman extends SEX
  /**
    * 样例类:
    *   语法: case class 类名([val/var] 属性名:属性类型)自动有 @BeanProperty
    * 样例对象:
    *   语法: case object object名称
    *
    *
    *伴生类：
    * class Person(val name:String,val age:Int)
    *
    * object Person{
    *   def apply(name:String,age:Int) = new Person(name,age)
    * }
    *
    * Person("zhangsan",20)
    */
  def main(args: Array[String]): Unit = {

    val person = Person("zhangsan",20)
    println(person)
    println(person.getName)

    //person.age = 100
    //println(person)

    m1(Man)

    person match {
      case Person(name,age) =>
        println(s"name=${name} age=${age}")
    }

    val student = new Student("lisi",100)

    student match {
/*      case x:Student =>
        println(s"x=${x.name}")*/
      case Student(name,age) =>
        println(s"name:${name} age:${age}")
    }
  }

  class Student(val name:String,val age:Int)

  object Student{

    def unapply(arg: Student): Option[(String, Int)] = {
      if(arg==null)
        None
      else
        Some((arg.name,arg.age))
    }
  }
  def m1(sex:SEX) = {
    println(".......")
  }
}
3.8 赋值匹配
object $08_MatchParam {

  def main(args: Array[String]): Unit = {

      
    val tuple: (String, String, String) = m1(2,3)
    tuple match {
      case (x,y,z) => println("..")
    }
    //tuple._1，取第一个元素
      
      
    //简化版  
    val (t1,t2,t3) = m1(2,3)
    println(t1)//**
    println(t2)//+++
    println(t3)//2+3=5
	
      
      
    //匹配第三个元素
    val List(_,_,a,_*) = List(1,2,3,4,5)
    println(a)
	//打印结果 3
      
      
      
    val Array(x,y,z) = Array(1,2,3)
    println(x,y,z)
	//打印结果（1，2，3）
      
      
      
    val map  =Map[String,Int] ( ("aa",1),("bb",2) )

    for( i<- map )
      println(i)	//（aa,1） (bb,2)
	//简化版
    for( (k,v)<- map)
      println(k,v)	//（aa,1）（bb,2）
  }

  def m1(x:Int,y:Int) = {

    println(s"${x} ${y}")

    ("*"*x,"+"*y,s"${x}+${y}=${x+y}")
  }
}
3.9 偏函数

不使用match的模式匹配

object $09_MatchPartialFunction {

  /**
    * 偏函数：[不使用match的模式匹配]
    *     val func:PartialFunction[IN,OUT] = {
    *        case .. => ..
    *     }
    */
  def main(args: Array[String]): Unit = {

    val func:PartialFunction[Any,Int] = {
      case x:String =>
        println("string")
        10
      case y:Int =>
        println("int")
        20
      case _ =>
        println("other")
        30
    }

    val i: Int = func(100)
    println(i)	//20

    val school = List(
      ("北京小学",("小学一班",("1001","zhangsan",20))),
      ("北京小学",("小学一班",("1002","lisi",22))),
      ("北京小学",("小学一班",("1003","wangwu",23)))
    )

    //偏函数的应用场景
    val func1:PartialFunction[(String,(String,(String,String,Int))),String] = {
      case (schoolName,(className,(sid,sname,age))) => sname
    }
	println(school.map(func1))
      
    println(school.map({
      case (schoolName,(className,(sid,sname,age))) => sname
    }))
  }
}
暂未想好、
关注
专栏目录
Scala模式匹配-值匹配与简单类型匹配
行者
12-19 2844
在Scala的模式匹配中，可以使用类型、通配符、序列、正则表达式，甚至可以深入获取对象的状态。这种对象状态的获取遵循一定的协议，也就是对象内部状态的可见性由该类型的实现来控制，这样我们就可以获取暴露的状态并应用于变量中。对象的获取往往被称为“提取”或者“解构”。 1、简单匹配 简单匹配有点类似Java中的Switch语句，会匹配每一个确定的值。具体如下： def match_boole
Scala中的模式匹配match
shadon178 博客
09-01 1153
scala中的模式匹配类似与java中的switch语法，但功能比switch更加强大，且能匹配的方式各种各样。 我总结了一下，scala的match的匹配方式有如下几种： 通配模式 变量模式 构造器模式 序列模式 元组模式 类型模式
scala之模式匹配
worldchinalee的博客
05-30 1311
1.通配模式通配符 “_” 可以用来匹配任意对象。通常在模式匹配中作为最后一个匹配项，匹配其它所有的输入对象。比如：abstract class Expr case class Var(name:String) extends Expr case class Number(num:Double) extends Expr case class BinOp(operator:String,left:...
Scala之模式匹配(match case)
南风知我意
08-30 425
Scala的match表达式类似于其他语言中的switch语句，它可以提供给你在多个备选项中做选择。基本上match表达式可以让你使用任意的模式(pattern)做选择。
Scala之模式匹配和样例类
lixinkuan的博客
12-08 579
本章的要点： match表达式是更好的switch，不会有意外调入下一个分支 如果没有模式能够匹配，会抛出MatchError，可以用case _模式避免 模式可以包含一个随意定义的条件，称做守卫 你可以对表达式的类型进行匹配;优先选择模式匹配而不是isInstanceOf/asInstanceOf 你可以匹配数组，元祖，样例类的模式，然后匹配到不同部分绑定到变量 在for表达式中，不...
Scala 之 模式匹配
weixin_36630761的博客
08-11 280
转自：http://rscala.com/index.php/508.html Scala 提供了强大的模式匹配机制，应用也非常广泛。一个模式匹配包含了一系列备选项，每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。 与java switch case的差别 Scala是没有Java中的switch ca
scala的模式匹配
qq_42185397的博客
06-12 418
Scala的模式匹配主要关键字为：match和case 匹配变量 var str:String = "Hello World" str(7) match{ case 'a' =>println("This is a") case 'b' =>println("This is b") case 'W' =>println("This is W") // _表示其他情况 ...
Scala-模式匹配
康师傅没有眼泪
07-23 343
每个备选项都包含了一个模式及一到多个表达式。Scala提供了强大的模式匹配机制，应用也非常广泛。一个模式匹配包含了一系列备选项，每个都开始于关键字。隔开了模式和表达式。
Scala - 模式匹配
阿年的博客
07-21 687
Scala中的模式匹配、模式守卫、匹配常量、类型、数组、列表、元组、对象以及样例类
浅谈Scala模式匹配
08-18
Scala 模式匹配详解 Scala 模式匹配是 Scala 语言中的一种强大语言特性，它允许开发者通过模式匹配来处理不同的数据类型和值。模式匹配的基本语法是 `e match { case Pattern1 => do Something case Pattern2 if-...
scala正则表达式与模式匹配.doc
10-09
Scala 正则表达式与模式匹配 Scala 正则表达式是 Scala 语言中的一种强大工具，用于模式匹配和字符串处理。在 Scala 中，正则表达式可以通过两种方式创建：通过 `r` 方法直接将字符串转换成正则表达式对象，或者...
scala语言for循环中的模式匹配
10-09
本文将详细介绍 Scala 语言 for 循环中的六种模式匹配方式：变量模式匹配、常量模式匹配、变量绑定模式匹配、类型模式匹配、构造函数模式匹配和序列模式匹配。 变量模式匹配 在 Scala 语言中，变量模式匹配是最...
Scala中正则表达式以及与模式匹配结合(多种方式)
08-25
在Scala中，正则表达式是处理文本模式匹配的强大工具，它能够识别和操作字符串中的复杂模式。Scala的模式匹配提供了一种灵活的方式来对数据进行解构和分类，当与正则表达式结合时，这种能力得到了极大的提升。 首先...
Scala之模式匹配pattern-matching与偏函数PartialFunctions
zp17834994071的博客
07-13 989
模式匹配(pattern matching) pattern matching 可以说是 scala 中十分强大的一个语言特性，当然这不是 scala 独有的，但这不妨碍它成为 scala 的语言的一大利器。 要理解模式匹配(pattern-matching)，先把这两个单词拆开，先理解什么是模式(pattern)，这里所的模式并不是设计模式里的模式。 而是数据结构上的，这个模式用于描述一个结构的组成。 我们很容易联想到“正则表达”里的模式，不错，这个pattern和正则里的pattern相似，不过适用范围
scala set集合
2301_80936715的博客
11-04 398
不可变集合：它的元素是不可以进行更新操作的，只有可变集合才可以进行元素的更新，使用集合调用update方法可以直接更新元素。1.添加单个或多个元素：+= ，添加集合：++=2.移除元素：-=和--=
Scala的访问权限
2401_87129058的博客
11-04 251
Scala 中的属性成员、方法和构造器这三种变量可以通过访问控制符控制访问权限。不同的访问控制符可以决定是否可以被外部类访问。
Scala的访问权限。
2401_87129116的博客
11-04 556
Scala中的访问权限和Java一致，采用public, private, protected三种访问权限。在不声明访问权限的情况下，Scala使用public作为默认权限private为私有属性，只有在类的内部和伴生对象中可用protected为受保护权限，同类、子类可以访问，但是同包不行Scala中的private限定符比Java更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。
Scala 的例题：银行账户钱存取功能
最新发布
2401_87129058的博客
11-04 280
（5）private[package]访问权限。（4）private[this]访问权限。（2）protected 访问权限。private[this]方法。（3）private 访问权限。private 方法。
ScalaJoins库：扩展Scala连接模式匹配能力
Scala Joins库基于提取器提供的可扩展模式匹配，将连接集成到Scala中。这个库支持具有多个同步事件和守卫的连接模式，同时也与演员模式集成。这种集成方式允许在更高级的同步模式的上下文中使用连接模式，例如未来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值