scala----option类型及偏函数、异常处理、正则表达式

最新推荐文章于 2023-11-10 08:39:51 发布
最新推荐文章于 2023-11-10 08:39:51 发布
阅读量855 收藏
点赞数 1
分类专栏： Scala 大数据 文章标签： 大数据 scala hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40585384/article/details/121656155
版权
本文详细介绍了Scala中的模式匹配机制，包括简单模式匹配、类型匹配、守卫、匹配样例类、匹配集合、变量声明中的模式匹配以及匹配for表达式。此外，还探讨了Option类型在处理可能的空值时的作用，以及如何使用偏函数简化代码。同时，正则表达式的应用也被提及，展示了如何校验和处理字符串。最后，文章讨论了异常处理的try-catch-finally结构，以及如何通过提取器实现类的模式匹配。
摘要由CSDN通过智能技术生成

1、模式匹配

Scala中有一个非常强大的模式匹配机制，应用也非常广泛, 例如:

  • 判断固定值
  • 类型查询
  • 快速获取数据

1.1 简单模式匹配

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

变量 match {
    case "常量1" => 表达式1
    case "常量2" => 表达式2
    case "常量3" => 表达式3
    case _ => 表达式4 // 默认匹配项
}

执行流程

  1. 先执行第一个case, 看 变量值 和 该case对应的常量值 是否一致.
  2. 如果一致, 则执行该case对应的表达式.
  3. 如果不一致, 则往后执行下一个case, 看 变量值 和 该case对应的常量值 是否一致.
  4. 以此类推, 如果所有的case都不匹配, 则执行 case _ 对应的表达式.

示例

import scala.io.StdIn

//案例: 模式匹配之简单匹配
object ClassDemo01 {
  def main(args: Array[String]): Unit = {
    //1. 提示用户录入字符串并接收.
    println("请录入一个字符串: ")
    var str = StdIn.readLine()
    //2. 判断字符串是否是指定的内容, 并接收结果.
    val result = str match {
      case "hadoop" => "大数据分布式存储和计算框架"
      case "zookeeper" => "大数据分布式协调服务框架"
      case "spark" => "大数据分布式内存计算框架"
      case _ => "未匹配"
    }
    //3. 打印结果.
    println(result)
    println("-" * 15) //分割线.
    //简写形式
    str match {
      case "hadoop" => println("大数据分布式存储和计算框架")
      case "zookeeper" => println("大数据分布式协调服务框架")
      case "spark" => println("大数据分布式内存计算框架")
      case _ => println("未匹配")
    }
  }
}

1.2 匹配类型

除了匹配数据之外, match表达式还可以进行类型匹配。如果我们要根据不同的数据类型，来执行不同的逻辑，也 可以使用match表达式来实现。

对象名 match {
    case 变量名1: 类型1 => 表达式1
    case 变量名2: 类型2 => 表达式2
    case 变量名3: 类型3 => 表达式3
    ...
    case _ => 表达式4
}
  • 注意: 如果case表达式中无需使用到匹配到的变量，可以使用下划线代代替

示例

//案例: 模式匹配之匹配类型
object ClassDemo02 {
  def main(args: Array[String]): Unit = {
    //1. 定义一个变量为Any类型，然后分别给其赋值为"hadoop"、1、1.0
    val a: Any = 1.0
    //2. 定义模式匹配，然后分别打印类型的名称
    val result = a match {
      case x: String => s"${x} 是String类型的数据"
      case x: Double => s"${x} 是Double类型的数据"
      case x: Int => s"${x} 是Int类型的数据"
      case _ => "未匹配"
    }
    //3. 打印结果
    println(result)
    //4. 优化版, 如果在case校验的时候, 变量没有被使用, 则可以用_替代.
    val result2 = a match {
      case _: String => "String"
      case _: Double => "Double"
      case _: Int => "Int"
      case _ => "未匹配"
    }
    //打印结果
    println(result2)
  }
}

1.3 守卫

所谓的守卫指的是 在case语句中添加if条件判断 , 这样可以让我们的代码更简洁, 更优雅.

变量 match {
    case 变量名 if条件1 => 表达式1
    case 变量名 if条件2 => 表达式2
    case 变量名 if条件3 => 表达式3
    ...
    case _ => 表达式4
}

示例

import scala.io.StdIn

//案例: 模式匹配之守卫
object ClassDemo03 {
  def main(args: Array[String]): Unit = {
    //1. 从控制台读入一个数字a（使用StdIn.readInt）
    println("请录入一个整数: ")
    var num = StdIn.readInt()
    //2. 模式匹配
    num match {
      //2.1 如果 a >= 0 而且 a <= 3，打印[0-3]
      case a if a >= 0 && a <= 3 => println("[0-3]")
      //2.2 如果 a >= 4 而且 a <= 8，打印[4,8]
      case a if a >= 4 && a <= 8 => println("[4-8]")
      //2.3 否则，打印未匹配
      case _ => println("未匹配")
    }
  }
}

1.4 匹配样例类

Scala中可以使用模式匹配来匹配样例类，从而实现可以快速获取样例类中的成员数据。后续，我们在开发Akka案 例时，还会经常用到。

对象名 match {
    case 样例类型1(字段1, 字段2, 字段n) => 表达式1
    case 样例类型2(字段1, 字段2, 字段n) => 表达式2
    case 样例类型3(字段1, 字段2, 字段n) => 表达式3
    ...
    case _ => 表达式4
}
  1. 样例类型后的小括号中, 编写的字段个数要和该样例类的字段个数保持一致.
  2. 通过match进行模式匹配的时候, 要匹配的对象必须声明为: Any类型.

示例

//案例: 模式匹配之匹配样例类
object ClassDemo04 {

  //1. 创建两个样例类Customer、Order
  //1.1 Customer包含姓名、年龄字段
  case class Customer(var name: String, var age: Int)

  //1.2 Order包含id字段
  case class Order(id: Int)

  def main(args: Array[String]): Unit = {
    //2. 分别定义两个案例类的对象，并指定为Any类型
    val c: Any = Customer("糖糖", 73)
    val o: Any = Order(123)
    val arr: Any = Array(0, 1)
    //3. 使用模式匹配这两个对象，并分别打印它们的成员变量值
    c match {
      case Customer(a, b) => println(s"Customer类型的对象, name=${a}, age=${b}")
      case Order(c) => println(s"Order类型, id=${c}")
      case _ => println("未匹配")
    }
  }
}

1.5 匹配集合

除了上述功能之外, Scala中的模式匹配，还能用来匹配数组, 元组, 集合(列表, 集, 映射)等。

Array(1,x,y) // 以1开头，后续的两个元素不固定
Array(0) // 只匹配一个0元素的元素
Array(0, ...) // 可以任意数量，但是以0开头

示例

//案例: 模式匹配之匹配数组
object ClassDemo05 {
  def main(args: Array[String]): Unit = {
    //1. 定义三个数组.
    val arr1 = Array(1, 2, 3)
    val arr2 = Array(0)
    val arr3 = Array(1, 2, 3, 4, 5)
    //2. 通过模式匹配, 找到指定的数组.
    arr2 match {
      //匹配: 长度为3, 首元素为1, 后两个元素无所谓.
      case Array(1, x, y) => println(s"匹配长度为3, 首元素为1, 后两个元素是: ${x}, ${y}")
      //匹配: 只有一个0元素的数组
      case Array(0) => println("匹配: 只有一个0元素的数组")
      //匹配: 第一个元素是1, 后边元素无所谓的数组.
      case Array(1, _*) => println("匹配: 第一个元素是1, 后边元素无所谓的数组")
      //其他校验项
      case _ => println("未匹配")
    }
  }
}

List(0) // 只保存0一个元素的列表
List(0,...) // 以0开头的列表，数量不固定
List(x,y) // 只包含两个元素的列表

//案例: 模式匹配之匹配列表
object ClassDemo06 {
  def main(args: Array[String]): Unit = {
    //1. 定义列表.
    var list1 = List(0)
    var list2 = List(0, 1, 2, 3, 4, 5)
    var list3 = List(1, 2)
    //2. 通过match进行模式匹配
    //思路一: 通过List()来实现.
    list1 match {
      case List(0) => println("匹配: 只有一个0元素的列表")
      case List(0, _*) => println("匹配: 0开头, 后边元素无所谓的列表")
      case List(x, y) => println(s"匹配: 只有两个元素的列表, 元素为: ${x}, ${y}")
      case _ => println("未匹配")
    }
    //思路二: 采用关键字优化 Nil, tail
    list1 match {
      case 0 :: Nil => println("匹配: 只有一个0元素的列表")
      case 0 :: tail => println("匹配: 0开头, 后边元素无所谓的列表")
      case x :: y :: Nil => println(s"匹配: 只有两个元素的列表, 元素为: ${x}, ${y}")
      case _ => println("未匹配")
    }
  }
}

匹配元祖

(1, x, y) // 以1开头的、一共三个元素的元组
(x, y, 5) // 一共有三个元素，最后一个元素为5的元组

示例

//案例: 模式匹配之匹配元组
object ClassDemo07 {
  def main(args: Array[String]): Unit = {
    //1. 定义两个元组.
    val a = (1, 2, 3)
    val b = (3, 4, 5)
    val c = (3, 4)
    //2. 通过模式匹配, 匹配指定的元素
    a match {
      case (1, x, y) => println(s"匹配: 长度为3, 以1开头, 后两个元素无所谓的元组, 这里后两个元素
        是: $ {x}, ${y}")
      case (x, y, 5) => println(s"匹配: 长度为3, 以5结尾, 前两个元素无所谓的元素, 这里前两个元素
        是: $ {x}, ${y}")
      case _ => println("未匹配")
    }
  }
}

1.6 变量声明中的模式匹配

在定义变量时，可以使用模式匹配快速获取数据. 例如: 快速从数组,列表中获取数据 .

示例

//案例: 演示变量声明中的模式匹配.
object ClassDemo08 {
  def main(args: Array[String]): Unit = {
    //1. 生成包含0-10数字的数组，使用模式匹配分别获取第二个、第三个、第四个元素
    //1.1 生成包含0-10数字的数组
    val arr = (0 to 10).toArray
    //1.2 使用模式匹配分别获取第二个、第三个、第四个元素
    val Array(_, x, y, z, _*) = arr;
    //1.3 打印结果.
    println(x, y, z)
    println("-" * 15)
    //2. 生成包含0-10数字的列表，使用模式匹配分别获取第一个、第二个元素
    //2.1 生成包含0-10数字的列表，
    val list = (0 to 10).toList
    //2.2 使用模式匹配分别获取第一个、第二个元素
    //思路一: List() 实现
    val List(a, b, _*) = list
    //思路二: ::, tail 实现.
    val c :: d :: tail = list
    //2.3 打印结果.
    println(a, b)
    println(c, d)
  }
}

1.7 匹配for表达式

Scala中还可以使用模式匹配来匹配for表达式，从而实现快速获取指定数据, 让我们的代码看起来更简洁, 更优雅.

示例

//案例: 模式匹配之匹配for表达式.
object ClassDemo09 {
  def main(args: Array[String]): Unit = {
    //1. 定义变量记录学生的姓名和年龄.
    val map1 = Map("张三" -> 23, "李四" -> 24, "王五" -> 23, "赵六" -> 26)
    //2. 获取所有年龄为23的学生信息.
    //2.1 格式一: 通过if语句实现.
    for ((k, v) <- map1 if v == 23) println(s"${k} = ${v}")
    //分割线.
    println("-" * 15)
    //2.2 格式二: 通过固定值实现.
    for ((k, 23) <- map1) println(k + " = 23")
  }
}

2. Option类型

2.1 概述

实际开发中, 在返回一些数据时, 难免会遇到空指针异常(NullPointerException), 遇到一次就处理一次相对来讲还是 比较繁琐的. 在Scala中, 我们返回某些数据时，可以返回一个Option类型的对象来封装具体的数据，从而实现有效 的避免空指针异常。

Scala中，Option类型表示可选值。这种类型的数据有两种形式：

  • Some(x)：表示实际的值

  • None：表示没有值

    注意: 使用getOrElse方法，当值为None时可以指定一个默认值.

示例

//案例: 演示Option类型
object ClassDemo10 {
  //1. 定义一个两个数相除的方法，使用Option类型来封装结果
  def div(a: Int, b: Int) = {
    if (b == 0) {
      None //除数为0, 没有结果.
    } else {
      Some(a / b) //除数不为0, 返回具体的结果.
    }
  }

  def main(args: Array[String]): Unit = {
    //2. 然后使用模式匹配来打印结果
    val result = div(10, 0)
    //思路一: 通过模式匹配来打印结果.
    result match {
      //不是除零，打印结果
      case Some(x) => println(x)
      //除零打印异常错误
      case None => println("除数不能为0")
    }
    println("-" * 15)
    //思路二: 采用getOrElse()方法实现.
    println(result.getOrElse(0))
  }
}

3. 偏函数

3.1 定义

偏函数提供了更简洁的语法，可以简化函数的定义。配合集合的函数式编程，可以让代码更加优雅。 所谓的偏函数是指 被包在花括号内没有match的一组case语句 , 偏函数是PartialFunction[A, B]类型的的一个实例对 象, 其中A代表输入参数类型, B代表返回结果类型.

3.2 格式

val 对象名 = { //这对大括号及其内部的一组case语句, 就组成了一个偏函数.
    case 值1 => 表达式1
    case 值2 => 表达式2
    case 值3 => 表达式3
    ...
}

示例

//案例: 演示偏函数
object ClassDemo11 {
  def main(args: Array[String]): Unit = {
    //1. 定义一个偏函数, 根据指定格式返回
    val pf: PartialFunction[Int, String] = {
      case 1 => "一"
      case 2 => "二"
      case 3 => "三"
      case _ => "其他"
    }
    //2. 调用方法
    println(pf(1))
    println(pf(2))
    println(pf(3))
    println(pf(4))
  }
}

3.4 示例二: 结合map函数使用

示例

//案例: 偏函数使用, 结合map函数
object ClassDemo12 {
  def main(args: Array[String]): Unit = {
    //1. 定义一个列表，包含1-10的数字
    val list1 = (1 to 10).toList
    //核心: 通过偏函数结合map使用, 来进行模式匹配
    val list2 = list1.map {
      //2 请将1-3的数字都转换为[1-3]
      case x if x >= 1 && x <= 3 => "[1-3]"
      //3 请将4-8的数字都转换为[4-8]
      case x if x >= 4 && x <= 8 => "[4-8]"
      //4 将其他的数字转换为(8-*]
      case _ => "(8-*]"
    }
    //5. 打印结果.
    println(list2)
  }
}

4. 正则表达式

4.1 概述

所谓的正则表达式指的是 正确的, 符合特定规则的式子 , 它是一门独立的语言, 并且能被兼容到绝大多数的编程语言 中. 在scala中, 可以很方便地使用正则表达式来匹配数据。具体如下:

  1. Scala中提供了 Regex类 来定义正则表达式.
  2. 要构造一个Regex对象，直接使用 String类的r方法 即可.
  3. 建议使用三个双引号来表示正则表达式，不然就得对正则中的反斜杠进行转义.

4.2 格式

val 正则对象名 = """具体的正则表达式""".r
注意: 使用findAllMatchIn方法可以获取到所有正则匹配到的数据(字符串).

示例

//案例: 校验邮箱是否合法.
object ClassDemo13 {
  def main(args: Array[String]): Unit = {
    //需求: 定义一个正则表达式，来匹配邮箱是否合法
    //1. 定义一个字符串, 表示邮箱.
    val email = "qq12344@163.com"
    //2. 定义一个正则表达式, 用来校验邮箱.
    /*
    . 表示任意字符
    + 数量词, 表示前边的字符出现至少1次, 至多无所谓.
    @ 表示必须是@符号, 无特殊含义.
    \. 因为.在正则中有特殊的含义, 所以要转移一下, 使它变成普通的.
    */
    val regex = """.+@.+\..+""".r
    //3. 打印结果.
    if (regex.findAllMatchIn(email).size != 0) {
      //合法邮箱
      println(s"${email} 是一个合法的邮箱!")
    } else {
      println(s"${email} 是一个非法的邮箱!")
    }
  }
}

示例2

//案例: 过滤所有不合法的邮箱.
object ClassDemo14 {
  def main(args: Array[String]): Unit = {
    //1. 定义列表, 记录邮箱.
    val emlList = List("38123845@qq.com", "a1da88123f@gmail.com", "zhansan@163.com",
      "123afadff.com")
    //2. 定义正则表达式.
    val regex = """.+@.+\..+""".r
    //3. 通过 过滤器 获取所有的不合法的邮箱.
    val list = emlList.filter(x => regex.findAllMatchIn(x).size == 0)
    //4. 打印结果.
    println(list)
  }
}

示例3

//案例: 获取邮箱运营商.
object ClassDemo15 {
  def main(args: Array[String]): Unit = {
    //1. 定义列表, 记录邮箱.
    val emlList = List("38123845@qq.com", "a1da88123f@gmail.com", "zhansan@163.com",
      "123afadff.com")
    //2. 定义正则表达式.
    val regex = """.+@(.+)\..+""".r
    //3. 根据 模式匹配 匹配出所有合法的邮箱及其对应的运营商.
    val result = emlList.map {
      //email就是emlList这个列表中的每一个元素.
      //company表示: 正则表达式中你用()括起来的内容, 也就是分组的数据.
      case email @ regex(company) => email -> s"${company}"
      case email => email -> "未匹配"
    }
    //4. 打印结果
    println(result)
  }
}

5. 异常处理

格式

try {
	//可能会出现问题的代码
}
catch{
    case ex:异常类型1 => //代码
    case ex:异常类型2 => //代码
}
finally {
	//代码
}
  1. try中的代码是我们编写的业务处理代码.
  2. 在catch中表示当出现某个异常时，需要执行的代码.
  3. 在finally中，写的是不管是否出现异常都会执行的代码

示例

//案例: 演示异常处理.
object ClassDemo16 {
  def main(args: Array[String]): Unit = {
    //1. 通过try.catch来处理 除数为零异常.
    try {
      //可能出问题的代码
      val i = 10 / 0
    } catch {
      //出现问题后的解决方案.
      //case ex:Exception => println("代码出问题了!")
      case ex: Exception => ex.printStackTrace()
    }
    println("你好！")
    println("-" * 15) //我是分割线.
    //2. 抛出一个异常对象.
    throw new Exception("我是一个Bug!")
    println("Hello, Scala!") //这行代码并不会被执行.
  }
}

6、提取器(Extractor)

概述 我们之前已经使用过Scala中非常强大的模式匹配功能了，通过模式匹配，我们可以快速获取样例类对象中的成员 变量值。

例如：

// 1. 创建两个样例类
case class Person(name: String, age: Int)

case class Order(id: String)

def main(args: Array[String]): Unit = {
  // 2. 创建样例类对象，并赋值为Any类型
  val zhangsan: Any = Person("张三", 20)
  val order1: Any = Order("001")
  // 3. 使用match...case表达式来进行模式匹配
  // 获取样例类中成员变量
  order1 match {
    case Person(name, age) => println(s"姓名：${name} 年龄：${age}")
    case Order(id1) => println(s"ID为：${id1}")
    case _ => println("未匹配")
  }
}

那是不是所有的类都可以进行这样的模式匹配呢？答案是： 不是 。一个类要想支持模式匹配，则必须要实现一个提取器。

1. 提取器指的就是 unapply()方法 .
2. 样例类自动实现了apply()、unapply()方法, 无需我们手动定义.

6.2 格式

要实现一个类的提取器，只需要在该类的伴生对象中实现一个unapply方法即可。

def unapply(stu:Student):Option[(类型1, 类型2, 类型3...)] = {
    if(stu != null) {
    	Some((变量1, 变量2, 变量3...))
    }
    else {
   		 None
    }
}

6.3 示例

object ClassDemo17 {

  //1. 创建一个Student类，包含姓名年龄两个字段
  class Student(var name: String, var age: Int)

  //2. 实现一个类的提取器，并使用match表达式进行模式匹配，提取类中的字段。
  object Student { //伴生对象.
    def apply(name: String, age: Int) = new Student(name, age) //免new
    def unapply(s: Student): Option[(String, Int)] = { //相当于把对象 拆解成 其各个属性

      if (s != null)
        Some(s.name, s.age)
      else
        None
    }
  }

  //main方法, 作为程序的主入口.
  def main(args: Array[String]): Unit = {
    //3. 创建Student类的对象.
    val s = new Student("糖糖", 73) //普通方式创建对象.
    val s2 = Student("糖糖", 73) //免new, 创建对象, apply方法保证
    //4. 打印对象的属性值
    println(s2.name + "..." + s.age) //普通方式获取对象的属性值
    //5. 通过提取器获取对象中的方法.
    val result = Student.unapply(s2)
    println(result)
  }
}
我:yueda
关注
专栏目录
Scala(11) -- 模式匹配、Option类型、偏函数、正则表达式、异常处理、提取器（Extractor）
erainm
09-21 388
1. 模式匹配 2. Option类型 3. 偏函数 4. 正则表达式 5. 异常处理 6. 提取器(Extractor) 7. 案例
scala_Option、偏函数、正则表达式
Imflash的博客
09-21 299
文章目录Option类型定义示例一示例二偏函数定义示例一示例二正则表达式定义示例一示例二示例三 Option类型 使用Option类型，可以用来有效避免空引用(null)异常。也就是说，将来我们返回某些数据时，可以返回一个Option类型来替代。 定义 scala中，Option类型来表示可选值。这种类型的数据有两种形式： Some(x)：表示实际的值 None：表示没有值 使用...
Scala中的模式匹配——Option类型中的模式匹配
大唐帝国—前营
11-19 698
/** * Option类型中的模式匹配 * Option类型有两个子类，分别是Some和None（单例对象） * None是一个case object，它同Some一样都extends Option类，只不过Some是case class， * 对于case class我们已经很熟悉了，那case object又是怎么样的呢？ * 对比反编译之后的代码可以看出，case ob
python 矩阵相乘不能交换
jacke121的专栏
08-14 1889
import numpy as np a =np.array([[1,2] ,[3 ,4],[5,6]]) b =np.array( [[5 ,6] ,[7 ,8],[9,10]]) print (np.matmul(a ,b.T)) print (np.dot(b ,a.T)) 结果： [[ 17 23 29] [ 39 53 67] [ 61 83 105]] [[ 17 39 61] [ 23 53 83] [ 29 67 105]] ...
Scala中的选项(Options )
最新发布
biqidaoer的专栏
11-10 664
在Java中使用null，偶尔需要处理它。如果未处理，则可能给出NullPointerException。当接受从函数返回的值时可以使用Option，该函数可以在周期时间返回null，否则返回一些值。这两个值之一是“ none”，其他值可以是程序中有效的任何对象。是一个包含一个值的容器，该值可以是两个不同值之一。不会发生此异常，这就是其用法更有效的原因。在Java编程中Option与。当函数失败时，为空类的实例。一个类的实例，当函数成功时。
【scala专栏_持续更新】23_scala正则表达式+模式匹配+偏函数+提取器
专注大数据与自由
11-20 529
【大纲】 【正文】
scala正则表达式与模式匹配.doc
10-09
Scala 正则表达式是 Scala 语言中的一种强大工具，用于模式匹配和字符串处理。在 Scala 中，正则表达式可以通过两种方式创建：通过 `r` 方法直接将字符串转换成正则表达式对象，或者直接显式地调用 `Regex` 构造函数...
scala 正则超详细总结！！！
WCL0520的博客
09-17 1039
一、scala正则表达式-1 Scala支持多种正则表达式解析方式 （1）String.matches()方法 例： var a = "!123".matches("[a-zA-Z0-9]{4}") println(a) 结果：false （2）正则表达式模式匹配 var source = Source.fromFile("D:\\wcl.txt","UTF-8") var lines = source.getLines.toArray val reg = """([A-Z]+) ([0-9]{4}-[0
Scala之模式匹配pattern-matching与偏函数PartialFunctions
zp17834994071的博客
07-13 992
模式匹配(pattern matching) pattern matching 可以说是 scala 中十分强大的一个语言特性，当然这不是 scala 独有的，但这不妨碍它成为 scala 的语言的一大利器。 要理解模式匹配(pattern-matching)，先把这两个单词拆开，先理解什么是模式(pattern)，这里所的模式并不是设计模式里的模式。 而是数据结构上的，这个模式用于描述一个结构的组成。 我们很容易联想到“正则表达”里的模式，不错，这个pattern和正则里的pattern相似，不过适用范围
Spark SQL常用表达式示例
wang_wbq的博客
03-23 2176
Spark SQL常用表达式示例 版权声明：本文为博主原创文章，未经博主允许不得转载。 手动码字不易，请大家尊重劳动成果，谢谢 作者：http://blog.csdn.net/wang_wbq 本文使用spark-shell来演示我平时常用的一些Spark SQL表达式，来帮助大家更好体会Spark SQL的使用方式。 所有可用函数可以使用这篇文章中的方法进行查看...
【scala】Option类型详解
weixin_44441131的博客
07-30 2495
scala中的Option操作
scala scala之Option
a3125504x的博客
07-17 289
scala之Option 在Scala中Option类型用样例类来表示可能存在或也可能不存在的值 当数据集使用Option时，可以使用getOrElse代替 Option类型有2个子类 Some:包装了某值 // 源码 /** Class `Some[A]` represents existing values of type * `A`. * * @author Martin Odersky * @version 1.0, 16/07/2003 */ @SerialVersio
scala快速入门系列【模式匹配】
大数据梦想家
01-29 1724
        本篇作为scala快速入门系列的第二十九篇博客，为大家带来的是关于模式匹配的内容。 文章目录模式匹配简单模式匹配匹配类型守卫匹配样例类 模式匹配         scala中有一个非常强大的模式匹配机制，可以应用在很多场...
[Scala基础]--类型转换(String to Double 、Long、Float和Int)
热门推荐
欢迎来到我的博客，一起探索代码里的世界！
10-18 5万+
前言： 关于Scala的类型转换方式有许多种，但初学时仍会忽略一些重要细节，比如异常情况的捕获等等。 那么本文将简单介绍Scala的String进行相关的类型转换，供大家学习参考。 主要内容： 1、Scala的富包装器:富操作和富类列表 2、Scala的隐式转换的目的 通过隐式转换，程序员可以在...
Scala 用Option[T] 避免NullPointerException
bitcarmanlee的博客
07-23 1550
1.java里的Null Pointer Exception写过一阵子的Java后, 应该会对NullPointerException (NPE)这种东西很熟悉，基本上会碰到这种异常，就是你有一个变量是 null，但你却调用了它的方法，或是取某个的值。 举例而言，下面的 Java 代码就会抛出NPE异常：例1: String s1 = null; System.out.println("lengt
spark.read.option(jdbc)参数
卡奥斯道的博客
10-25 5640
Property Name Meaning url The JDBC URL to connect to. The source-specific connection properties may be specified in the URL. e.g.,jdbc:postgresql://localhost/test?user=fred&password=secre...
Scala中常见的容器 Option(选项)
Winterto1990的博客
08-03 5660
Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。 Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。 接下来我们来看一段代码： // 虽然 Scala 可以不定义变量的类型，不过为了清楚些，我还是 // 把他显示的定义上了 val
scala中的Option
天道酬勤
01-09 4478
避免null的使用 大多数语言都有一个特殊的关键字或者对象表示一个对象的引用是“无”，在java里，它是null。在java里，null是一个关键字，不是一个对象，所以对它调用任何方法都是非法的。但是为什么要在程序员希望返回一个对象的时候，返回一个关键字呢？ Scala的Option类型 为了让所有东西都是对象的目标更加一致，也为了遵循函数式编程的习惯，scala鼓励你在变量和函数返回值可能...
Scala死代码检测工具scala-linter编译器插件发布
由于"scala-linter"项目代码打包的压缩文件名称为"scala-linter-master"，这暗示了它可能是一个开源项目，并且当前版本为初始或主要版本。对于想要深入了解或参与到该项目的开发者来说，可以从这个压缩包中获取最新...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我:yueda

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

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

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

打赏作者

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

抵扣说明：

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

余额充值