scala学习总结10（match、样例类）

最新推荐文章于 2020-05-05 11:05:03 发布

念达

最新推荐文章于 2020-05-05 11:05:03 发布

阅读量180

点赞数

分类专栏：大数据之Scala

本文链接：https://blog.csdn.net/weixin_44757575/article/details/101450358

版权

大数据之Scala 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

match

基本介绍：
① Scala中的模式匹配类似于Java中的switch语法，但是功能更加强大。
②模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明。
③当需要匹配时，会从第一个case分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。
④如果所有case都不匹配，那么会执行case _ 分支，类似于Java中default语句。
- 示例：
```
val oper = '*'
val a = 30
val b = 11
var res = 0;
oper match{
  case '+' => res = a + b
  case '-' => res = a - b
  case '*' => res = a * b
  case '/' => res = a / b
  case_ => println("oper error")	  
}
println(res)
```
- 注意细节：
  ①如果所有case都不匹配，又没有写case _ 分支，那么会抛出MatchError
  ②每个case中，不用break语句，自动中断case
  ③=> 后面的代码块到下一个 case，是作为一个整体执行，若有多行代码，{}可忽略
- 案例1（case _ 在前面）：

def test2()={
  for (ch <- "+-3!") {
    var sign = 0
    var digit = 0
    ch match {
      case _  => digit = 3
      case '+' => sign = 1
      case '-' => sign = -1
    }
    println(ch + " " + sign + " " + digit)
  }
}
//输出结果：
//+ 0 3
//- 0 3
//3 0 3
//! 0 3

案例2（最后有两个case _ ）：

def test1()={
  for (ch <- "+-3!") {
    var sign = 0
    var digit = 0
    ch match {
      case '+' => sign = 1
      case '-' => sign = -1
      case _  => digit = 3
      case _  => sign = 2
    }
    println(ch + " " + sign + " " + digit)
  }
}
//输出结果：
//+ 1 0
//- -1 0
//3 0 3
//! 0 3

案例3（如果在case关键字后跟变量名，那么match前表达式的值会赋给那个变量）

def test3()={
  val ch = "Curry"
  ch match {
    case "SC" => println("ok~")
    case mychar => println("ok~" + mychar)
    case _ => println ("ok~~")
  }
}
//输出：
//ok~Curry

案例4（类型匹配）

def test4()={
  val a = 4
  val obj = if(a == 1) 1
  else if(a == 2) "2"
  else if(a == 3) BigInt(3)
  else if(a == 4) Map("aa" -> 1)
  else if(a == 5) Map(1 -> "aa")
  else if(a == 6) Array(1, 2, 3)
  else if(a == 7) Array("aa", 1)
  else if(a == 8) Array("aa")

  val result = obj match {
    case a : Int => a
    case b : Map[String, Int] => "对象是一个字符串-数字的Map集合"
    case c : Map[Int, String] => "对象是一个数字-字符串的Map集合"
    case d : Array[String] => "对象是一个字符串数组"
    case e : Array[Int] => "对象是一个数字数组"
    case f : BigInt => Int.MaxValue
    case _ => "啥也不是"
  }
  println(result)//对象是一个字符串-数字的Map集合
}

//注：在进行类型匹配时，编译器会预先检测是否有可能的匹配，如果没有则报错.
//如果 case _ 出现在match中间，则表示隐藏变量名，即不使用,而不是表示默认匹配。

匹配数组

基本介绍：
①Array(0) 匹配只有一个元素且为0的数组。
②Array(x,y) 匹配数组有两个元素，并将两个元素赋值为x和y。当然可以依次类推Array(x,y,z) 匹配数组有3个元素的等等…
③Array(0,_*) 匹配数组以0开始。

示例：

for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0),
Array(1, 1, 0), Array(1, 1, 0, 1))) {
val result = arr match {
 case Array(0) => "0"
 case Array(x, y) => x + "=" + y
 case Array(0, _*) => "以0开头和数组"
 case _ => "什么集合都不是"
}
 println("result = " + result)
}

匹配列表

def test6()={
  for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1, 0, 0))) {
    val result = list match {
      case 0 :: Nil => "0" //
      case x :: y :: Nil => x + " " + y //
      case 0 :: tail => "0 ..." //
      case _ => "something else"
    }
    println(result)
  }
}

匹配元组

def test7()={
  for (pair <- Array((0, 1), (1, 0), (1, 1),(1,0,2))) {
    val result = pair match { // 
      case (0, _) => "0 ..." //
      case (y, 0) => y // 
      case _ => "other" //.
    }
    println(result)
  }
}

对象匹配

object TestMatch1 {
  def main(args: Array[String]): Unit = {
    // 模式匹配使用：
    val number = 36.0
    number match {
      case Square(n) => println(n)
      case _ => println("nothing matched")
    }
  }
}

object Square {
  def unapply(z: Double): Option[Double] = Some(math.sqrt(z))
  def apply(): Double = Square()
}

样例类：

基本介绍：
①样例类仍然是类
②样例类用case关键字进行声明。
③样例类是为模式匹配而优化的类
④在样例类对应的伴生对象中提供apply方法让你不用new关键字就能构造出相应的对象
⑤提供unapply方法让模式匹配可以工作
⑥将自动生成toString、equals、hashCode和copy方法
样例类实例1:
当我们有一个类型为Amount的对象时，可以用模式匹配来匹配他的类型，并将属性值绑定到变量(即：把样例类对象的属性值提取到某个变量,该功能有用)

for (amt <- Array(Dollar(1000.0), Currency(1000.0, "RMB"), NoAmount)) {
        val result = amt match {
	  //说明
          case Dollar(v) => "$" + v
	  //说明
          case Currency(v, u) => v + " " + u
          case NoAmount => ""
        }
        println(amt + ": " + result)
}

样例类案例2:
样例类的copy方法和带名参数：
copy创建一个与现有对象值相同的新对象，并可以通过带名参数来修改某些属性

val amt = Currency(29.95, "RMB")
val amt1 = amt.copy() //创建了一个新的对象，但是属性值一样
val amt2 = amt.copy(value = 19.95) //创建了一个新对象，但是修改了货币单位
val amt3 = amt.copy(unit = "英镑")//..
println(amt)
println(amt2)
println(amt3)

case语句的中置(缀)表达式
- 基本介绍：
  什么是中置表达式？1 + 2，这就是一个中置表达式。如果unapply方法产出一个元组，你可以在case语句中使用中置表示法。比如可以匹配一个List序列；

    List(1, 3, 5, 9) match { 
	//1.两个元素间::叫中置表达式,至少first，second两个匹配才行.
	//2.first 匹配第一个 second 匹配第二个, rest 匹配剩余部分(5,9)
        case first :: second :: rest => println(first + “ ” + second + “ ” + rest.length) //
        case _ => println("匹配不到...")
    }

匹配嵌套结构
1. 案例-商品捆绑打折出售：
  现在有一些商品，请使用Scala设计相关的样例类，完成商品捆绑打折出售。要求
  商品捆绑可以是单个商品，也可以是多个商品。
  打折时按照折扣x元进行设计.
  能够统计出所有捆绑商品打折后的最终价格
2. 创建样例类：

abstract class Item // 项

case class Book(description: String, price: Double) extends Item
//Bundle 捆 ， discount: Double 折扣 ， item: Item* , 
case class Bundle(description: String, discount: Double, item: Item*) extends Item

匹配嵌套结构(就是Bundle的对象)

//给出案例表示有一捆数，单本漫画（40-10） +文学作品(两本书)（80+30-20） = 30 + 90 = 120.0
val sale = Bundle("书籍", 10,  Book("漫画", 40), Bundle("文学作品", 20, Book("《阳关》", 80), Book("《围城》", 30)))

知识点1-将descr绑定到第一个Book的描述
如何取出
val sale = Bundle("书籍", 10, Book("漫画", 40), Bundle("文学作品", 20, Book("《阳关》", 80), Book("《围城》", 30)))
这个嵌套结构中的 “漫画”：

   val res = sale match  {
        //如果我们进行对象匹配时，不想接受某些值，则使用_ 忽略即可，_* 表示所有
        case Bundle(_, _, Book(desc, _), _*) => desc
        }

知识点2-通过@表示法将嵌套的值绑定到变量。_*绑定剩余Item到rest
请思考：如何将 “漫画” 和
val sale = Bundle(“书籍”, 10, Book(“漫画”, 40), Bundle(“文学作品”, 20, Book("《阳关》", 80), Book("《围城》", 30)))
这个嵌套结构中的 “漫画” 和黄色的部分绑定到变量，即赋值到变量中：

val result2 = sale match {
    case Bundle(_, _, art @ Book(_, _), rest @ _*) => (art, rest)
    }
    println(result2)
    println("art =" + result2._1)
    println("rest=" + result2._2)

最佳实践案例-商品捆绑打折出售
现在有一些商品，请使用Scala设计相关的样例类，完成商品可以捆绑打折出售。要求：
①商品捆绑可以是单个商品，也可以是多个商品。
②打折时按照折扣xx元进行设计.
③能够统计出所有捆绑商品打折后的最终价格

def price(it: Item): Double = {
    it match {
    case Book(_, p) => p
    //生成一个新的集合,_是将its中每个循环的元素传递到price中it中。递归操作,分析一个简单的流程
    case Bundle(_, disc, its @ _*) => its.map(price _).sum - disc
    }
}

密封类
- 基本介绍
  ① 如果想让case类的所有子类都必须在申明该类的相同的源文件中定义，可以将样例类的通用超类声明为sealed，这个超类称之为密封类。
  ②密封就是不能在其他文件中定义子类。

念达

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
scala学习总结10（match、样例类）

match基本介绍：① Scala中的模式匹配类似于Java中的switch语法，但是功能更加强大。②模式匹配语法中，采用match关键字声明，每个分支采用case关键字进行声明。③当需要匹配时，会从第一个case分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。④如果所有case都不匹配，那么会执行case _ 分支，类似于Java中def...
复制链接

扫一扫