大数据——Scala的分支控制及模式匹配

最新推荐文章于 2024-08-14 08:34:27 发布
最新推荐文章于 2024-08-14 08:34:27 发布
阅读量1w 收藏 2
点赞数 1
文章标签： scala 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sweet19920711/article/details/118572438
版权

目录

一、分支控制if-else

1.1 单分支

1.2 双分支

1.3 多分支

二、嵌套分支

三、模式匹配

3.1 基本语法

3.2 if模式守卫

3.3 正则模式守卫

3.4 类型模式守卫

3.5 匹配数组

3.6 匹配列表

3.7 匹配元组

3.8 匹配对象及样例类

3.9 变量声明中的模式匹配

3.10 for表达式中的模式匹配

一、分支控制if-else

1.1 单分支

1.1.1 基本语法

        当条件表达式为true时，执行{}中的代码块

if(条件表达式){
    执行代码块
}

1.1.2 案例

        输入人的年龄，如果该同志的年龄小于 18 岁，则输出“童年” 
import scala.io.StdIn

object TestIf {
  def main(args: Array[String]): Unit = {
    println("input age:")
    val age = StdIn.readInt()
    if(age<18){
      println("童年")
    }
  }
}

1.2 双分支

1.2.1 基本语法

if(条件表达式){
    执行代码块1
}else{
    执行代码块2
}

1.2.2 案例

        输入年龄，如果年龄小于 18 岁，则输出“童年”。否则，输出“成年”。 
import scala.io.StdIn

object TestIfElse {
  def main(args: Array[String]): Unit = {
    println("input age:")
    val age = StdIn.readInt()
    if(age<18){
      println("童年")
    }else{
      println("成年")
    }
  }
}

1.3 多分支

1.3.1 基本语法

if(条件表达式1){
    执行代码块1
}else if(条件表达式2){
    执行代码块2
}
...
else{
    执行代码块n
}

1.3.2 案例

        输入年龄，如果年龄小于 18 岁，则输出“童年”。如果年龄大于等于 18 且小于等于 30 ，则输出 “ 中年 ” ，否则，输出“老年”。 
import scala.io.StdIn

object TestIfElse {
  def main(args: Array[String]): Unit = {
    println("input age:")
    val age = StdIn.readInt()
    if(age<18){
      println("童年")
    }else if(age>=18 && age<30){
      println("中年")
    }else{
      println("老年")
    }
  }
}

注意：

        1.Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。 

import scala.io.StdIn

object TestIfElse {
  def main(args: Array[String]): Unit = {
    println("input age")
    var age = StdIn.readInt()
    val res :String = if (age < 18){
      "童年"
    }else if(age>=18 && age<30){
      "中年"
    }else{
      "老年"
    }
    println(res)
  }
}

        2.Scala 中返回值类型不一致，取它们共同的祖先类型。


import scala.io.StdIn

object TestIfElse {
  def main(args: Array[String]): Unit = {
    println("input age")
    var age = StdIn.readInt()
    val res:Any = if (age < 18){
      "童年"
    }else if(age>=18 && age<30){
      "中年"
    }else{
      100
    }
    println(res)
  }
}

        3.Java 中的三元运算符可以用 if else 实现                

                如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号， if 只对最近
        的一行逻辑代码起作用。 
import scala.io.StdIn

object TestIfElse {
  def main(args: Array[String]): Unit = {
    println("input age")
    var age = StdIn.readInt()
    //省略大括号只对最近的一句代码起作用
    val res:Any = if (age < 18) "童年" else "成年" "不起作用"
    println(res)
  }
}

二、嵌套分支

        在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层。分支外面的分支结构称为外层分支。嵌套分支不要超过 3 层。
2.1 基本语法 
if(条件表达式1){
    if(条件表达式2){
        代码块
    }else{
        代码块
    }
}

2.2 案例

        如果输入的年龄小于 18 ，返回 “ 童年 ” 。如果输入的年龄大于等于 18 ，需要再判断：如果年龄大于等于 18 且小于 30 ，返回 “ 中年 ” ；如果其他，返回 “ 老年 ” 。 
import scala.io.StdIn

object TestIfElse {
  def main(args: Array[String]): Unit = {
    print("input age：\t")
    var age = StdIn.readInt()
    val result = if(age<18){
      "童年"
    }else{
      if(age<30){
        "中年"
      }else{
        "老年"
      }
    }
    println(result)
  }
}

三、模式匹配

Scala 中的模式匹配 类似于 Java 中的 switch 语法

3.1 基本语法

3.1.1 模式匹配语法中，采用match 关键字声明，每个分支采用 case 关键字进行声明，当需要匹配时，会从第一个 case分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有 case 都不匹配，那么会执行 case _ 分支，类似于 Java 中 default 语句。 
import scala.io.StdIn

object TestMatchCase {
  def main(args: Array[String]): Unit = {
    print("请输入你需要的服务号：\t")
    val dial = StdIn.readInt()
    val result = dial match {
      case 1=>"充值"
      case 2=>"话费查询"
      case 3=>"人工服务"
      case _=>"无此服务"
    }
    println(result)
  }
}

3.1.2 说明

（1）如果所有 case 都不匹配，那么会执行 case _ 分支，类似于 Java 中 default 语句，若此时没有 case _ 分支，那么会抛出 MatchError。
（2）每个 case 中，不需要使用 break 语句，自动中断 case。
（3）match case 语句可以匹配任何类型，而不只是字面量。
（4）=> 后面的代码块，直到下一个 case 语句之前的代码是作为一个整体执行，可以
使用{}括起来，也可以不括

3.2 if模式守卫

3.2.1 说明

        如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫。

3.2.2 案例

        当成绩大于等于90时等级为A，成绩大等于于80时等级为B，成绩大于等于60时等级为C，成绩低于60时等级为D

import scala.io.StdIn

object TestMatchCase {
  def main(args: Array[String]): Unit = {
    print("请输入成绩：\t")
    val score = StdIn.readInt()
    val result = score match {
      case _ if(score >= 90) => "A"
      case _ if(score >= 80) => "B"
      case _ if(score >= 60) => "C"
      case _ => "D"
    }
    println(result)
  }
}

3.3 正则模式守卫

3.3.1 说明

        如果想要表达匹配某个正则表达式，就需要在模式匹配中增加正则守卫。

3.3.2 案例

        判断输入的字符串是邮箱、手机号还是身份证号

import scala.io.StdIn

object TestMatchCase {
  def main(args: Array[String]): Unit = {
    print("请输入字符串：\t")
    val value = StdIn.readLine()
    val rMail = "\\w+@\\w{2,}\\.(com|cn|org|net)".r
    val rPhone = "(1)[3-9]\\d{9}".r
    val rPid = "\\d{17}(\\d|X)".r
    val result = value match {
      case rMail(value) => "MAIL"
      case rPhone(value) => "PHONE"
      case rPid(value) => "PID"
      case _ => "unknown"
    }
    println(result)
  }
}

3.4 类型模式守卫

3.4.1 说明

        需要进行类型判断时，可以使用模式守卫

3.4.2 案例

object TestMatchClass {
  def describe(x: Any) = x match {
    case i: Int => "Int"
    case s: String => "String hello"
    case m: List[_] => "List"
    case c: Array[Int] => "Array[Int]"
    case someThing => "something else " + someThing
  }
  def main(args: Array[String]): Unit = {
    //泛型擦除
    println(describe(List(1, 2, 3, 4, 5)))
    //数组例外，可保留泛型
    println(describe(Array(1, 2, 3, 4, 5, 6)))
    println(describe(Array("abc")))
  }
}

3.5 匹配数组

3.5.1 说明

        scala 模式匹配可以对集合进行精确的匹配，例如匹配只有两个元素的、且第一个元素为 0 的数组。
3.5.2 案例 
object TestMatchArray {
  def main(args: Array[String]): Unit = {
    for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0),
      Array(1, 1, 0), Array("hello", 90),Array(1, 1, 0, 1))) { //对一个数组集合进行遍历
      val result = arr match {
        case Array(0) => "0" //匹配 Array(0) 这个数组
        case Array(x, y) => x + "," + y //匹配有两个元素的数组，然后将将元素值赋给对应的 x,y
        case Array(0, _*) => "以 0 开头的数组" //匹配以 0 开头和数组
        case _ => "something else"
      }
      println("result = " + result)
    }
  }
}

3.6 匹配列表

object TestMatchList {
  def main(args: Array[String]): Unit = {
    //list 是一个存放 List 集合的数组
    for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1,
      0, 0), List(88))) {
      val result = list match {
        case List(0) => "0" //匹配 List(0)
        case List(x, y) => x + "," + y //匹配有两个元素的 List
        case List(0, _*) => "0 ..."
        case List(x) => x
        case _ => "something else"
      }
      println(result)
    }
  }
}

3.7 匹配元组

object TestMatchTuple {
  def main(args: Array[String]): Unit = {
    //对一个元组集合进行遍历
    for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) {
      val result = tuple match {
        case (0, _) => "0 ..." //是第一个元素是 0 的元组
        case (y, 0) => "" + y + "0" // 匹配后一个元素是 0 的对偶元组
        case (a, b) => "" + a + " " + b
        case _ => "something else" //默认
      }
      println(result)
    }
  }
}

3.8 匹配对象及样例类

3.8.1 基本语法

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

object User {
  def apply(name: String, age: Int): User = new User(name, age)
  def unapply(user: User): Option[(String, Int)] = {
    if (user == null)
      None
    else
      Some(user.name, user.age)
  } }
object TestMatchUnapply {
  def main(args: Array[String]): Unit = {
    val user: User = User("zhangsan", 11)
    val result = user match {
      case User("zhangsan", 11) => "yes"
      case _ => "no"
    }
    println(result)
  }
}
小结
➢
val user = User("zhangsan",11) ，该语句在执行时，实际调用的是 User 伴生对象中的
apply 方法，因此不用 new 关键字 就能构造出相应的对象。
➢
当将 User("zhangsan", 11) 写在 case 后时 [case User("zhangsan", 11) => "yes"] ，会默
认调用 unapply 方法 ( 对象提取器 ) ， user 作为 unapply 方法的参数 ， unapply 方法
将 user 对象的 name 和 age 属性提取出来，与 User("zhangsan", 11) 中的属性值进行
匹配
➢
case 中对象的 unapply 方法 ( 提取器 ) 返回 Some ，且所有属性均一致，才算匹配成功 ,
属性不一致，或返回 None ，则匹配失败。
➢
若只提取对象的一个属性，则提取器为 unapply (obj:Obj): Option[ T ]
若提取对象的多个属性，则提取器为 unapply (obj:Obj): Option[ (T1,T2,T3…) ]
若提取对象的可变个属性，则提取器为 unapplySeq (obj:Obj): Option[ Seq[T] ]
3.8.2 样例类
（ 1 ）语法：
        case class Person (name: String, age: Int)
（ 2 ）说明
        1 样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中 自动提供了一些常用的方法，如 apply 、 unapply 、 toString 、 equals 、 hashCode 和 copy 。
        2 样例类是为模式匹配而优化的类，因为其默认提供了 unapply 方法，因此，样例 类可以直接使用模式匹配，而无需自己实现 unapply 方法。
        3 构造器中的每一个参数都成为 val ，除非它被显式地声明为 var （不建议这样做）
（ 3 ）实操
        上述匹配对象的案例使用样例类会节省大量代码 
case class User(name: String, age: Int)
object TestMatchUnapply {
 def main(args: Array[String]): Unit = {
 val user: User = User("zhangsan", 11)
 val result = user match {
 case User("zhangsan", 11) => "yes"
 case _ => "no"
 }
 println(result)
 } }

3.9 变量声明中的模式匹配

case class Person(name: String, age: Int)
object TestMatchVariable {
 def main(args: Array[String]): Unit = {
 val (x, y) = (1, 2)
 println(s"x=$x,y=$y")
 val Array(first, second, _*) = Array(1, 7, 2, 9)
 println(s"first=$first,second=$second")
 val Person(name, age) = Person1("zhangsan", 16)
 println(s"name=$name,age=$age")
 } }

3.10 for表达式中的模式匹配

object TestMatchFor {
  def main(args: Array[String]): Unit = {
    val map = Map("A" -> 1, "B" -> 0, "C" -> 3)
    for ((k, v) <- map) { //直接将 map 中的 k-v 遍历出来
      println(k + " -> " + v) //3 个
    }
    println("----------------------")
    //遍历 value=0 的 k-v ,如果 v 不是 0,过滤
    for ((k, 0) <- map) {
      println(k + " --> " + 0) // B->0
    }
    println("----------------------")
    //if v == 0 是一个过滤的条件
    for ((k, v) <- map if v >= 1) {
      println(k + " ---> " + v) // A->1 和 c->33
    }
  }
}

Vicky_Tang
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
常见的大数据技术类型有哪些
中琛魔方大数据
05-28 3888
　　随着互联网的不断发展，越来越多的企业和用户都开始接触和学习大数据技术，它与机器学习、人工智能、区块链、物联网和增强现实等其他技术密切相关。因此，许多行业已经在大数据分析技术方面作了投入，比如银行、离散制造和流程制造等行业。 　　目前比较常见的一些大数据技术都有哪些类型？今天我们就一起来了解一下，目前比较常见的一些大数据技术都有哪些类型。 　　1.数据湖 　　数据湖是个庞大的数据存储库，从不同来源收集数据，并以自然状态存储起来。切莫与数据仓库混为一谈，数据仓库基本上执行同样的功能，...
scala 模式匹配
Devin
07-15 126
/** * 定义偏函数用PartialFunction * PartialFunction[T1,T2],T1为传入的参数类型，T2为返回值类型 * 偏函数体中的case只会匹配一个，匹配到了就不会继续往下匹配 */ val func: PartialFunction[String, Int] = { case "a" =&gt; 1 case "b...
scala 分支控制 (单分支、双分支、多分支)、 分支判断的返回值
热门推荐
不是一枚开发
07-15 4万+
输入年龄，如果年龄小于18岁，则输出“童年”。如果年龄大于等于18且小于等于30，则输出“青年”，如果年龄大于30小于等于50，则输出”中年”，否则，输出“老年”scala中如果逻辑代码只有一行，花括号可省略，若需要三元运算符，可使用。（1）下面代码中的变量result类型为Any类型，用于匹配不同分支的执行结果。，需要在执行之前将数据类型确定，编译器在编译时就会考虑多种情况下的通用方案。（2）下面代码中的变量result类型为String类型。视为一个整体，返回值为Unit，被赋予变量b。...
scala模式匹配 if_Scala教程–使用if-else块和匹配条件执行
04-23 989
scala模式匹配 if 前言 这是面向初学者的Scala教程的第3部分。 该博客上还有其他文章，您可以在我正在为其创建的计算语言学课程的链接页面上找到这些链接和其他资源。 此外，您可以在“ JCG Java教程”页面上找到本教程和其他教程系列。 有条件的 变量来了，变量就去了，根据输入，它们取不同的值。 我们通常需要根据这些值制定不同的行为。 例如，让我们模拟奥斯丁的一家酒吧招标，该酒...
Scala基础语法入门（四）Scala流程控制之分支控制
web15870359587的博客
06-12 245
??♂??♂ 写在前面 ?? 案例：一个篮球员完成花式扣篮，请输入您的打分，分数小于6 则输出一句话 2、双分支 ?? 案例：一个篮球员完成花式扣篮，请输入您的打分，分数小于6 则输出一句话，分数大于=6 输出另一句话 3、多分支 ?? 案例：一个篮球员完成花式扣篮，请输入您的打分，分数小于6 则输出一句话，分数大于=6小于9 输出另一句话 分数大于= 9 输出另外一句话 1、Scala中 fi else语句其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。好我们再来看下面的代码：再看看
【Scala】Scala的控制结构（分支、循环）
毕业于东北大学软件工程专业，现就职于字节跳动
12-12 579
Scala基础简介 Scala流程控制 Scala函数方法 Scala集合体系 Scala面向对象 Scala函数式编程 文章目录1 1
Scala 模式匹配
Simple 专栏
09-17 203
模式匹配是Scala函数值和闭包后第二大应用功能。Scala为模式匹配提供了极大的支持，处理消息。 模式匹配包括一系列备选项，每个替代项以关键字大小写为单位。每个替代方案包括一个模式和一个或多个表达式，如果模式匹配，将会进行评估计算。箭头符号=&gt;将模式与表达式分离。 尝试以下示例程序，它显示匹配的整数值。 示例 object Demo { def main(args: Arr...
大数据——Scala进阶（begin）
01-20
在大数据领域，编程语言的选择至关重要，而Scala因其强大的功能和对大数据处理的高效支持而备受青睐。本文将探讨Scala的进阶知识，首先从统一类型系统开始。 在Scala中，`Any`是最顶级的类型，它包含了所有类型的...
大数据课程-Scala编程基础-5.Scala模式匹配_lk_edit.ppt
01-01
本课程内容涵盖多个关键概念，如模式匹配、样例类、隐式函数和异常处理及泛型，这些都是Scala语言强大特性的体现。 首先，Scala的模式匹配是一种强大的控制流构造，类似于Java中的switch语句，但更为灵活。它允许...
大数据—Scala
06-12
Scala语言概述、运算符、程序流程控制、数据结构之集合、Map映射、过滤、化简、折叠、扫描、拉链、视图、并行集合、高阶函数、函数柯里化、偏函数、参数推断、控制抽象、Trait、面向对象编程、异常处理、惰性函数、...
尚硅谷大数据之Scala语言核心编程.pdf
07-04
尚硅谷大数据scala语言核心编程，是大数据开发必备的技能。
浅谈Scala模式匹配
08-18
Scala 模式匹配详解 Scala 模式匹配是 Scala 语言中的一种强大语言特性，它允许开发者通过模式匹配来处理不同的数据类型和值。模式匹配的基本语法是 `e match { case Pattern1 => do Something case Pattern2 if-...
Scala 嵌套分支
曾经蜡笔没有小新
06-12 2024
嵌套分支说明 在一个分支结构中又完整的嵌套了另外一个完整的分支结构，里面的分支的结构称为内层分支，外面的分支结构称为外层分支。 嵌套分支最好不要超过三层 基本语法 ...
Scala中的分支和循环
zhangxm_qz的博客
12-29 923
分支 Scala 通过if else 语法实现程序分支示例如下： object IfElseDemo01 { def main(args: Array[String]): Unit = { testif } def testif(): Unit ={ var age =StdIn.readInt();//从控制台读取一个年龄值 if(age>18){ ...
Scala学习笔记
J_zrm的博客
12-20 487
一、java和scala对比 方法和函数 1）scala方法：def 方法名（参数名：类型）：返回值类型={return "我是输出"} 2）java方法： 返回值类型 方法名(类型 参数名){} //scala def aaa(a:Int):Int={return 1} //java int aaa(int a){return 1;} 方法和函数 1）scala没有public，缺省就是公共的 2）没有startic，没有静态方法 3）没有void，有unit，表示没有返回值 class和object
scala嵌套分支应用案例
one111a的博客
07-29 476
** scala嵌套分支应用案例 ** 应用案例1 参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰，并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断 import scala.io._ object Exercise04 { def main(args: Array[String]): Unit = { println(“请输入运动员的成绩：”) val speed = Std...
关于大数据的两个大分支
cnhome的专栏
09-29 1640
Cloudera 引自 New Features in CDH 6.0.0 See below for new features in CDH 6.0.0, grouped by component: Apache Accumulo Apache Avro Apache Crunch Apache Flume Apache Hadoop Apache HBase Apache Hive / Hi...
Spark2.x 入门：套接字流（DStream）
最新发布
跟着大数据和AI去旅行
08-14 296
Spark Streaming可以通过Socket端口监听并接收数据，然后进行相应处理。 新建NetworkWordCount.scala代码文件，请在该文件中输入如下内容： package org.apache.spark.examples.streaming import org.apache.spark._ import org.apache.spark.streaming._ im
Scala编程基础：模式匹配与异常处理
内容包括Scala模式匹配的概念、样例类、隐式函数和异常及泛型的使用。课程材料全面，包含教学大纲、教案、实训文档等，适合教师进行教学使用。" 在Scala编程中，模式匹配是一种强大的控制流构造，它允许我们根据值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Vicky_Tang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值