精华内容
下载资源
问答
  • Scala 模式匹配

    2020-11-23 18:28:41
    功能函数中应用模式匹配(重点)比如在map函数中使用 1、场景:之前的map是这样的,因为不方便所以才会用模式匹配。让它处理方便 1)因为下划线1,下划线2时间长了就记不住 2)上面发现Map中每个都是tuple,...
    功能函数中应用模式匹配(重点)比如在map函数中使用
    1、场景:之前的map是这样的,因为不方便所以才会用模式匹配。让它处理方便
     
    1)因为下划线1,下划线2 时间长了就记不住
    2)上面发现Map 中每个都是tuple,tuple 是可以做模式匹配的,t 就是tuple
    3)开始模式匹配:把tuple 换成((prv,item,),cnt)
    4)prv对应着地区,item对应着商品,cnt 对应的就是数量
    5)map的时候做这样的转换
    这样就省去了下划线,看着和操作都更方便
     
    6) 在map的时候进行模式匹配的时候, 需要注意两点
    1、在没有进行匹配的时候,传递的都是一个tuple,是一个整体, ,因为有逗号,map方法就是传递一个参数,马丁认为这里是参数列表,而不是一个整体。
    所以在使用的时候就需要加上关键字,case
    2、因为在使用模式匹配的时候,可能会有多种case 情况,行数就会太多了, 所以map后面原本的小括号需要换成花括号{}
     
    功能函数会大量的使用模式匹配

    第二个小案例:
    结果:

    第三个小案例:
     
    自己对功能函数中模式匹配的理解:
    理解一下功能函数中的模式匹配吧。按照自己的理解
    功能函数传递的都是集合中的一个一个的元素,此时需要对元素进行模式匹配
    符合某个规则的元素进入一种操作逻辑,符合某种规则的元素进入一种逻辑
    以这个为例: i和s 都是元素(符合某种规则的元素)
    =>左边的就是元素, =>右边的就是需要执行的逻辑
    代表元素传递进来,相应的元素走相应的通道,执行相应的逻辑
    展开全文
  • Scala模式匹配

    2020-10-21 15:25:55
    章节目录Scala模式匹配样例类 Scala模式匹配 Scala 提供了强大的模式匹配机制,应用也非常广泛。 一个模式匹配包含了一系列备选项,每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号...

    Scala模式匹配

    模式匹配是Scala中非常有特色,非常强大的一种功能。模式匹配,其实类似于Java中的swich case语法,即对一个值进行条件判断,然后针对不同的条件,进行不同的处理。

    但是Scala的模式匹配的功能比Java的swich case语法的功能要强大地多,Java的swich case语法只能对值进行匹配。但是Scala的模式匹配除了可以对值进行匹配之外,还可以对类型进行匹配、对Array和List的元素情况进行匹配、对case class进行匹配、甚至对有值或没值(Option)进行匹配。

    而且对于Spark来说,Scala的模式匹配功能也是极其重要的,在spark源码中大量地使用了模式匹配功能。因此为了更好地编写Scala程序,并且更加通畅地看懂Spark的源码,学好模式匹配都是非常重要的。

    1、模式匹配的基础语法

    1.1 对变量的值进行模式匹配

    Scala是没有Java中的switch case语法的,相对应的,Scala提供了更加强大的match case语法,即模式匹配,类替代switch case,match case也被称为模式匹配

    Scala的match case与Java的switch case最大的不同点在于,Java的switch case仅能匹配变量的值,比1、2、3等;而Scala的match case可以匹配各种情况,比如变量的类型、集合的元素、有值或无值

    match case的语法如下:变量 match { case 值 => 代码 }。如果值为下划线,则代表了不满足以上所有情况下的默认情况如何处理。此外,match case中,只要一个case分支满足并处理了,就不会继续判断下一个case分支了。(与Java不同,java的switch case需要用break阻止)

    match case语法最基本的应用,就是对变量的值进行模式匹配
    案例:

    def method1(x:Int):String={
      if (x==1){
        "one"
      }else if (x==2){
        "two"
      }else{
        "many"
      }
    }
    
    //模式匹配--简化代码
    def match1(x:Int):String = x match {
      case 1 =>"one"
      case 2 =>"two"
      case _ =>"many"
    }
    
    def main(args: Array[String]): Unit = {
          println(match1(2))
    }
    

    在这里插入图片描述

    1.2 模式匹配中使用if守卫

    Scala的模式匹配语法,有一个特点在于,可以在case后的条件判断中,不仅仅只是提供一个值,而是可以在值后面再加一个if守卫,进行双重过滤

    def match2(name:String,score:String)=score match {
      case "A" => println("excellent")
      case "B" => println("good")
      case "C" => println("just so so")
      case _ if name == "qian" => println(name + " you are good boy,come on!") //if守卫
      case _ => println("you need work harder")
    }
    match2("qian","D")
    

    在这里插入图片描述

    1.3 在模式匹配中进行变量赋值

    Scala的模式匹配语法,有一个特点在于,可以将模式匹配的默认情况,下划线’_'替换为一个变量名,此时模式匹配语法就会将要匹配的值赋值给这个变量,从而可以在后面的处理语句中使用要匹配的值

    为什么有这种语法??思考一下。因为只要使用用case匹配到的值,是不是我们就知道这个只啦!!在这个case的处理语句中,是不是就直接可以使用写程序时就已知的值!

    但是对于下划线_这种情况,所有不满足前面的case的值,都会进入_这种默认情况进行处理,此时如果我们在处理语句中需要拿到具体的值进行处理呢?那就需要使用这种在模式匹配中进行变量赋值的语法!!

    def match3(name:String,score:String)=score match {
      case "A" => println("excellent")
      case "B" => println("good")
      case "C" => println("just so so")
      case _ if name == "qian" => println(name + " you are good boy,come on!") //if守卫
      case _score => println("you need work harder,your score only:"+_score) //变量赋值
    }
    match3("zs","E")
    

    在这里插入图片描述

    2、对类型进行模式匹配

    Scala的模式匹配一个强大之处就在于,可以直接匹配类型,而不是值!!!这点是java的switch case绝对做不到的。

    理论知识:对类型如何进行匹配?其他语法与匹配值其实是一样的,但是匹配类型的话,就是要用“case 变量: 类型 => 代码”这种语法,而不是匹配值的“case 值 => 代码”这种语法。

    接下来我们来看一个不同数据类型的模式匹配案例:

    def match2(x:Any):Unit = x match {
      case 1 => println("输入的值为1")
      case i:Int => println("输入的值类型为Int类型,值为:"+i)
      case s:String => println("输入的值类型为String类型,值为:"+s)
      case _ => println("我不知道是啥")
    }
    def main(args: Array[String]): Unit = {
            match2(17)
            match2("abc")
    }
    

    在这里插入图片描述

    3、对Array和List的元素进行模式匹配

    对Array进行模式匹配,分别可以匹配带有指定元素的数组、带有指定个数元素的数组、以某元素打头的数组

    对List进行模式匹配,与Array类似,但是需要使用List特有的::操作符

    案例:对朋友打招呼

    
    ```scala
    //对Array进行模式匹配
    def match5(arr:Array[String])=arr match {
      case Array("KB09") => println("Hello KB09") //匹配一个元素
      case Array(girl1,girl2,girl3) => println("Hello "+girl1+"&"+girl2+"&"+girl3)//匹配三个元素
      case Array("KB09", _*) => println("Hello KB09*")//匹配以KB09开头,三个元素的话会被上面匹配,scala匹配机制是匹配到就停止
      case _ => println("Who are you?")
    }
    var arr1=Array("KB09","KB07","KB05","KB02") //Hello KB09*
    var arr2=Array("KB09")  //Hello KB09
    var arr3=Array("KB09","KB07","KB05") //Hello KB09&KB07&KB05
    var arr4=Array("KB02","KB09","KB07","KB05") //Who are you?
    match5(arr1)
    match5(arr2)
    match5(arr3)
    match5(arr4)
    

    在这里插入图片描述

    //对List进行模式匹配
     def greeting(list: List[String]) {      
       list match {        
     	 case "Leo" :: Nil => println("Hi, Leo!")        
     	 case girl1 :: girl2 :: girl3 :: Nil => println("Hi, girls, nice to meet you. " + girl1 + " and " + girl2 + " and " + girl3)        
     	 case "Leo" :: tail => println("Hi, Leo, please introduce your friends to me.")        
     	 case _ => println("hey, who are you?")      
       }    
     }    
     greeting(List("Leo","jack","poly","herry"))  
    
    

    4、Option与模式匹配

    Scala有一种特殊的类型,叫做Option。Option有两种值,一种是Some,表示有值,一种是None,表示没有值。

    Option通常会用于模式匹配中,用于判断某个变量是有值还是没有值,这比null来的更加简洁明了

    Option的用法必须掌握,因为Spark源码中大量地使用了Option,比如Some(a)、None这种语法,因此必须看得懂Option模式匹配,才能够读懂spark源码。

    案例:成绩查询

    val grades = Map("张三" -> "A", "李四" -> "B", "王五" -> "C")
    def getGrade(name:String)={
      val grade = grades.get(name)
      grade match {
        case Some(grade) => println(name+"的成绩为:" +grade)
        case None => println("没有"+name+"对应的成绩")
      }
    }
    getGrade("李四")
    getGrade("赵六")
    

    在这里插入图片描述

    5、case class与模式匹配

    Scala中提供了一种特殊的类,用case class进行声明,中文也可以称作样例类。case class其实有点类似于Java中的JavaBean的概念。即只定义field,并且由Scala编译时自动提供getter和setter方法,但是没有method。

    case class的主构造函数接收的参数通常不需要使用var或val修饰,Scala自动就会使用val修饰(但是如果你自己使用var修饰,那么还是会按照var来)

    Scala自动为case class定义了伴生对象,也就是object,并且定义了apply()方法,该方法接收主构造函数中相同的参数,并返回case class对象

    案例:

    //定义样例类
    case class Teacher(name:String,age:Int)
    
    def match3(teacher:Teacher):Unit = teacher match {
      case Teacher("gree",18) => println("hello gree")
      case Teacher("wenwen",21) => println("hello wenwen")
      case x:Teacher =>{
        println("hello "+x.name)
      }
    }
    
    def main(args: Array[String]): Unit = {
        val t=Teacher("gree",19)
        println(t)
        val t1=Teacher("gree",18)
        if (t.equals(t1)) {
          println("同一个人")
        }else{
          println("不是同一个人")
        }
    

    在这里插入图片描述
    参考博客:https://www.cnblogs.com/linxizhifeng/p/9269756.html

    展开全文
  • Scala模式匹配详解

    2020-10-22 15:29:31
    模式匹配Scala中非常有特色,非常强大的一种功能。模式匹配,其实*类似于Java中的swich case语法,即对一个值进行条件判断,然后针对不同的条件,进行不同的处理。 但是Scala模式匹配的功能比Java的swich case...

    模式匹配是Scala中非常有特色,非常强大的一种功能。模式匹配,其实*类似于Java中的swich case语法,即对一个值进行条件判断,然后针对不同的条件,进行不同的处理。

    但是Scala的模式匹配的功能比Java的swich case语法的功能要强大地多,Java的swich case语法只能对值进行匹配。但是Scala的模式匹配除了可以对值进行匹配之外,还可以对类型进行匹配、对Array和List的元素情况进行匹配、对case class进行匹配、甚至对有值或没值(Option)进行匹配。

    而且对于Spark来说,Scala的模式匹配功能也是极其重要的,在spark源码中大量地使用了模式匹配功能。因此为了更好地编写Scala程序,并且更加通畅地看懂Spark的源码,学好模式匹配都是非常重要的。
    1、模式匹配的基础语法

    //scala没有java中的switch case语法,但是有更强大的match case语法,即类型匹配,类替代
    //match case的语法如下:变量 match { case 值 => 代码 }。_代表不满足以上所有情况的默认。当有一个case分支满足了,就不会继续向下匹配了
    //match case语法最基本的应用,就是对变量的值进行模式匹配
    //案例:成绩评价
    object demo1{
      def main(args: Array[String]):Unit={
        def studentScore(score:String):Unit={
          score match{
            case "a"=>println("优秀")
            case "b"=>println("良好")
            case "c"=>println("一般")
            case _=>println("继续努力")
          //_代表其他
          }
        }
        studentScore("a")  //优秀
      }
    }
    

    在模式匹配中使用if守卫

    //scala模式匹配可以在case的条件判断后加上一个if,进行双重过滤
    object demo1{
      def main(args: Array[String]):Unit={
        def studentScore(name:String,score:String):Unit={
          score match{
            case "a"=>println("优秀")
            case "b"=>println("良好")
            case "c"=>println("一般")
            case _ if name=="xiong"=>println(name+"是个好孩子,加油")
            case _=>println("继续努力")
          }
        }
        studentScore("xiong","d") //xiong是个好孩子,加油
      }
    }
    

    在模式匹配中进行变量赋值

    //在进行case匹配值的时候,就只有这一个值(在这里是score),对于_(下划线)这种情况,即不满足以上所有情况的时候,都会进行默认的处理,此时我们可以使用变量赋值的方法在处理语句中加入这个值
    object demo1{
      def main(args: Array[String]):Unit={
        def studentScore(name:String,score:String):Unit={
          score match{
            case "a"=>println("优秀")
            case "b"=>println("良好")
            case "c"=>println("一般")
            case _ if name=="xiong"=>println(name+"是个好孩子,加油")
            case _score=>println(name+"要努力呀,你的成绩才为"+_score) //变量赋值
          }
        }
        studentScore("zhangSan","d") //zhangSan要努力呀,你的成绩才为d
      }
    }
    

    2、对类型进行模式匹配

    //scala可以直接匹配类型,而不是值
    //语法 case 变量:类型 => 代码 与上面有一些细微差别
    //案例:异常处理
    object demo1{
      def main(args: Array[String]):Unit={
        import java.io._
        def processException(e:Exception):Unit={
          e match{
            case e1:IllegalArgumentException=>println("you have illegal arguments ! exception is :"+e1)
            case e2:FileNotFoundException=>println("cannot find the file you need read or write ! exception is :"+e2)
            case e3:IOException=>println("you got an error while you were doing IO operation ! exception is :"+e3)
            case _:Exception=>println("cannot know which exception you have")
          }
        }
        processException(new IOException())
      }
    }
    

    3、对Array和List的元素进行模式匹配

    //对Array进行模式匹配,分别可以匹配带有指定元素的数组、带有指定个数的数组、以某元素开头的数组
    //对List进行模式匹配,与Array类似,但是需要使用List特有的::操作符
    
    //案列:对朋友打招呼
    object demo1{
      def main(args: Array[String]):Unit={
        def greeting(arr:Array[String]):Unit={
          arr match{
            case Array("Leo")=>println("Hi,Leo!") //匹配一个元素
            case Array(a,b,c)=>println("Hi,"+a+","+b+","+c) //匹配三个元素
            case Array("Leo",_*)=>println("Hi,Leo,please introduce your friends to me.") //匹配Leo开头的数组
            case _=>println("Hey,who are you?")
          }
        }
        greeting(Array("Leo")) //Hi,Leo!
        greeting(Array("Leo","Jack","Bob")) //Hi,Leo,Jack,Bob
        greeting(Array("Leo","Jack","Bob","Alice")) //Hi,Leo,please introduce your friends to me.
        greeting(Array("Jack","Bob","Alice","Leo")) //Hey,who are you?
      }
    }
    
    //List
    object demo1{
      def main(args: Array[String]):Unit={
        def greeting(list: List[String]){
          list match{
            case "Leo"::Nil=>println("Hi,Leo!")
            case "a"::"b"::"c"::Nil=>println("Hi,"+a+","+b+","+c) 
            case "Leo"::tail=>println("Hi,Leo,please introduce your friends to me.")
            case _=>println("Hey,who are you?")
          }
        }
        greeting(List("Leo")) //Hi,Leo!
        greeting(List("Leo","Jack","Bob")) //Hi,Leo,Jack,Bob
        greeting(List("Leo","Jack","Bob","Alice")) //Hi,Leo,please introduce your friends to me.
        greeting(List("Jack","Bob","Alice","Leo")) //Hey,who are you?
      }
    }
    

    case class 与模式匹配

    // Scala中提供了一种特殊的类,用case class进行声明,中文也可以称作样例类。case class其实有点类似于Java中的JavaBean的概念。即只定义field,并且由Scala编译时自动提供getter和setter方法,但是没有method。
    // case class的主构造函数接收的参数通常不需要使用var或val修饰,Scala自动就会使用val修饰(但是如果你自己使用var修饰,那么还是会按照var来)
    //  Scala自动为case class定义了伴生对象,也就是object,并且定义了apply()方法,该方法接收主构造函数中相同的参数,并返回case class对象
    
    //案例:学校门禁
    class Person
    case class Teacher(name:String,subject:String) extends Person
    case class Student(name:String,age:Int) extends Person
    case class Worker(name:String,work:String) extends Person
    case class Stranger() extends Person
    object demo1{
      def main(args: Array[String]):Unit={
        def entranceGuard(p:Person):Unit={
          p match{
            case Teacher(name,subject)=>println(s"Hello,$name,your teach is $subject")
            case Student(name,age)=>println(s"Hello,$name,your age is $age")
            case Worker(name,work) if work=="cleanner"==>println(s"Hello,$name,your work is $work")
            case Worker(name,work)=>println(s"Hello,$name,your work is $work,you should leavl 1 to 2 hours")
            case Stranger()=>println("stranger,you should leave right now")
          }
        }
        entranceGuard(Worker("Bob","cleanner"))
      }
    }
    

    Option与模式匹配

    //Scala有一种特殊的类型,叫做Option。Option有两种值,一种是Some,表示有值,一种是None,表示没有值。
    // Option通常会用于模式匹配中,用于判断某个变量是有值还是没有值,这比null来的更加简洁明了
    // Option的用法必须掌握,因为Spark源码中大量地使用了Option,比如Some(a)、None这种语法,因此必须看得懂Option模式匹配,才能够读懂spark源码。
    
    //案例:成绩评价
    object demo1{
      def main(args: Array[String]):Unit={
        val grades=Map("Leo"->"a","Jack"->"b","Jen"->"c")
        def getGrade(name:String){
          val grade=grades.get(name)
          grade match{
            case Some(grade)=>println("your grade is "+grade)
            case None=>println("Sorry, your grade is not in this system")
          }
        }
        getGrade("Leo") //your grade is a
        getGrade("J") // Sorry, your grade is not in this system
      }
    }
    
    展开全文
  • scala模式匹配

    2021-04-04 23:40:24
    Scala 提供了强大的模式匹配机制,应用也非常广泛。 一个模式匹配包含了一系列备选项,每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。 内容匹配 e.g....


    前言

    Scala 提供了强大的模式匹配机制,应用也非常广泛。

    一个模式匹配包含了一系列备选项,每个都开始于关键字 case。每个备选项都包含了一个模式及一到多个表达式。箭头符号 => 隔开了模式和表达式。


    内容匹配

    e.g.

    	//内容匹配:字符串:正则
    	//这里先确定邮箱格式正确之后再确认邮箱类型
        val email = "796282767@qq.com"
        val rst = email match {
          case i if (i.matches("^\\w+@[0-9a-z]{2,10}\\.(com|qq|edu|org)$")) => i match {
            case i if (i.matches(".*@qq\\..*")) => Some("qq")
            case i if (i.matches(".*@163\\..*")) => Some("163")
            case i if (i.matches(".*@hotmail\\..*")) => Some("hotmail")
          }
          case i => None
        }
        println(rst)
    

    e.g. result:

    Some(qq)
    

    类型匹配

    e.g.

    ("a", true, 18, 20.22, 'b', 20L, 20.1f).productIterator.foreach(x => println(x match {
          case i: String => s"$i is a String"
          case i: Boolean => s"$i is a Boolean"
          case i: Int => s"$i is a Int"
          case i: Double => s"$i is a Double"
          case i: Char => s"$i is a Char"
          case i: Long => s"$i is a Long"
          case i: Float => s"$i is a Float"
        }))
    

    e.g.result:

    a is a String
    true is a Boolean
    18 is a Int
    20.22 is a Double
    b is a Char
    20 is a Long
    20.1 is a Float
    

    结构匹配

    e.g.

    val products = Array((1, 2, 3), (1, (2, 3)), ((1, 2), 3))
        products.foreach(x => println(x match {
          case (a, b, c) => 'A'
          case ((a, b), c) => 'B'
          case (a, (b, c)) => 'C'
        }))
    

    e.g.result:

    A
    C
    B
    

    内容匹配:数值区间

    e.g.

    var age = 20;
        val unit = age match {
          case i if (i >= 18) => "mature"
          case i => "raw"
        }
        println(unit)
    

    e.g.result:

    mature
    

    原创作者:wsjslient

    作者主页:https://blog.csdn.net/wsjslient


    展开全文
  • Scala模式匹配模式匹配按元素匹配按照类型匹配偏函数:不需要match关键字 模式匹配 按元素匹配 import scala.util.Random object test1 { def main(args: Array[String]): Unit = { val a1 = Array(1, 2, 3) val ...
  • scala模式匹配功能十分强大 如果cae中涉及到多个类型,那么匹配的变量要不就都是a类型,要么是所有case中类型的父类, 比如 a match{ case x … case y … case z … } 要么 x y z 都是a的类型,要么 就是都是a的子类 ...
  • Scala中的模式匹配类似于Java中的switch语法,但是更加强大。 模式匹配语法中,采用match关键字声明,每个分支采用case关键字进行声明,当需要匹配时,会从第一个case分支开始,如果匹配成功,那么执行对应的逻辑...
  • 浅谈Scala模式匹配

    2020-08-18 23:37:28
    主要介绍了Scala模式匹配的的相关资料,文中讲解非常详细,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • scala模式匹配 if 前言 这是面向初学者的Scala教程的第3部分。 该博客上还有其他文章,您可以在我正在为其创建的计算语言学课程的链接页面上找到这些链接和其他资源。 此外,您可以在“ JCG Java教程”页面上找到...
  • 特定的模式匹配 像类型映射能匹配吗? 像java一样 ,类型参数没有保留到运行期,在模式匹配中无法识别类型, 但是数组是例外,数组的元素类型和元素值保存在一起,所以可以做模式匹配 ...
  • 说明:.r()方法简介:Scala中将字符串转换为正则表达式 /** You can follow a string with `.r`, turning it into a `Regex`. E.g. * * `"""A\w*""".r` is the regular expression for identifiers starting wi

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,756
精华内容 6,702
关键字:

scala模式匹配