首页 / SCALA / Scala入门到精通——第十五节 Case Class与模式匹配（二）

Scala入门到精通——第十五节 Case Class与模式匹配（二）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Scala入门到精通——第十五节 Case Class与模式匹配（二），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8018字，纯文字阅读大概需要12分钟。

内容图文

本节主要内容

模式匹配的类型
for控制结构中的模式匹配
option类型模式匹配

1. 模式的类型

1 常量模式

                object ConstantPattern{
  def main(args: Array[String]): Unit = {
    //注意，以下定义的是一个函数//函数的返回值利用的是模式匹配后的结果作为其返回值//还须要注意的是函数定义在main方法中//也即scala语言能够在一个函数中定义另外一个函数
    def patternShow(x:Any)=x match {
      case5 => "five"casetrue=>"true"case"test"=>"String"casenull=>"null"case Nil=>"empty list"case _  =>"Other constant"
    }    
    println(patternShow(5))
  }
}

2 变量模式

                
                    
                        object
                        VariablePattern{
                    def main(args: Array[String]): Unit = {
    def patternShow(x:Any)=x match {
      case5 => "five"//全部不是值为5的都会匹配变量y//比如"xxx"。则函数的返回结果就是"xxx"case y => y
    }   
    println(patternShow("xxx"))
  }
}

3 构造器模式

                
                    //构造器模式必须将类定义为case class
                    
                        case
                        class
                        Person
                        (name:String,age:Int)
                    
                    
                        object
                        ConstructorPattern {
                    def main(args: Array[String]): Unit = {
      val p=new Person("摇摆少年梦",27)
      def constructorPattern(p:Person)=p match {
        case Person(name,age) => "Person"case _ => "Other"
      }
  }
}

4 序列（Sequence)模式
序列模式指的是像Array、List这种序列集合进行模式匹配

                
object SequencePattern {
  def main(args: Array[String]): Unit = {
      val p=List("spark","hive","SparkSQL")
      def sequencePattern(p:List[String])=p match {
        //仅仅须要匹配第二个元素caseList(_,second,_*) => second
        case _ => "Other"
      }
      println(sequencePattern(p))
  }
}

5 元组模式

                
                    //匹配某个元组内容
                    
                        object
                        TuplePattern {
                    def main(args: Array[String]): Unit = {
      val t=("spark","hive","SparkSQL")
      def tuplePattern(t:Any)=t match {
        case (one,_,_) => one
        case _ => "Other"
      }
      println(tuplePattern(t))
  }
}

6 类型模式

                
                    //匹配传入參数的类型
                    
                        object
                        TypePattern {
                    def main(args: Array[String]): Unit = {

      def tuplePattern(t:Any)=t match {
        case t:String=> "String"case t:Int => "Integer"case t:Double=>"Double"
      }
      println(tuplePattern(5.0))
  }
}

上述代码假设不用模式匹配的话，要实现同样的功能，能够通过下列代码实现：

                def tuplePattern2(t:Any)={
        if(t.isInstanceOf[String]) "String"elseif(t.isInstanceOf[Int]) "Int"elseif(t.isInstanceOf[Double]) "Double"elseif(t.isInstanceOf[Map[_,_]]) "MAP"
      }

7 变量绑定模式

                object VariableBindingPattern {
  def main(args: Array[String]): Unit = {
       var t=List(List(1,2,3),List(2,3,4))      
       def variableBindingPattern(t:Any)= t match {
         //变量绑定，採用变量名（这里是e)//与@符号，假设后面的模式匹配成功。则将//总体匹配结果作为返回caseList(_,e@List(_,_,_)) => e
         case _ => Nil
       }

       println(variableBindingPattern(t))
  }
}
//编译运行后的输出结果为  List(2, 3, 4)

2. for控制结构中的模式匹配

                
                    
                        object
                        PatternInForLoop {
                    def main(args: Array[String]): Unit = {
    val m=Map("china"->"beijing","dwarf japan"->"tokyo","Aerican"->"DC Washington")
    //利用for循环对Map进行模式匹配输出。for((nation,capital)<-m)
      println(nation+": " +capital)
  }
}

正則表達式中的模式匹配：

                object RegexMatch {
  defmain(args: Array[String]): Unit = {
    val ipRegex="(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)".r
    for(ipRegex(one,two,three,four) <- ipRegex.findAllIn("192.168.1.1"))
    {
      println("IP子段1:"+one)
      println("IP子段2:"+two)
      println("IP子段3:"+three)
      println("IP子段4:"+four)
    }
  }
}

3. Option类型模式匹配

在前面的课程内容中，我们以前提到过Option类型，Option类型有两个子类。各自是Some和None（单例对象），本小节将从模式匹配的角度对Option类进行又一次思考。

以下给出的是Option类在scala语言中的类层次结构：
技术分享

Option类事实上是一个sealed class

                
                    //Option类的部分源代码
                    sealed
                    abstract
                    
                        class
                        Option[+A] extendsProductwithSerializable {
  self =>

  /** Returns true if the option is $none, false otherwise.
   */def isEmpty: Boolean

  /** Returns true if the option is an instance of $some, false otherwise.
   */def isDefined: Boolean = !isEmpty

以下给出的各自是Some及None的源代码：

                
                    /** Class `Some[A]` represents existing values of type
 *  `A`.
 *
 *  @author  Martin Odersky
 *  @version 1.0, 16/07/2003
 */
                    final
                    
                        case
                        class
                        Some[+A](x: A)extendsOption[A] {
                    def isEmpty = falsedef get = x
}


/** This case object represents non-existent values.
 *
 *  @author  Martin Odersky
 *  @version 1.0, 16/07/2003
 */caseobjectNoneextendsOption[Nothing] {def isEmpty = truedef get = thrownew NoSuchElementException("None.get")
}

以下的代码演示了其怎样应用到模式匹配中:

                
                    
                        object
                        OptionDemo
                        extends
                        App{
                    val m=Map("hive"->2,"spark"->3,"Spark MLlib"->4)

  def mapPattern(t:String)=m.get(t) match {
    case Some(x) => println(x);x
    case None => println("None");-1
  }

  println(mapPattern("Hive"))
}
//输出结果为：//None//-1

前面我们看到：None是一个case object。它同Some一样都extends Option类。仅仅只是Some是case class，对于case class我们已经非常熟悉了。那case object它又是怎么样的呢？假设我们定义了以下类：

                
                    //以下的类主要用于模拟Option,Some,None三个类或对象之间的关系
                    sealed
                    abstract
                    
                        class
                        A
                    
                    
                        case
                        class
                        B
                        (name:String,age:Int)
                        extends
                        A
                    
                    case
                    
                        object
                        CaseObject
                        extends
                        A{

}

上述代码编译后，生成的字节码文件例如以下：

                
                    D
                    :\ScalaWorkspace\ScalaChapter15\bin\cn\scala\xtwy 的文件夹

2015/08/0121:26    <DIR>          .
2015/08/0121:26    <DIR>          ..
2015/08/0121:26515A.class2015/08/0121:261,809B$.class2015/08/0121:264,320B.class2015/08/0121:261,722CaseObject$.class2015/08/0121:261,490CaseObject.class

单从编译后生成的类来看。它们之间似乎实现方式都一样，那究竟是什么样的呢？

class A的反编译后的代码例如以下：

                D:\ScalaWorkspace\ScalaChapter15\bin\cn\scala\xtwy>javap -private A.class
Compiled from "CaseObject.scala"
publicabstractclass cn.scala.xtwy.A {
  public cn.scala.xtwy.A();
}

case class B相应的字节码文件反编译后例如以下：

                
                    D:\ScalaWorkspace\ScalaChapter15\bin\cn\scala\xtwy>javap -private B.class
Compiled from "CaseObject.scala"
public class cn.scala.xtwy.B extends cn.scala.xtwy.A implements scala.Product,sc
ala.Serializable {
  private final java.lang.String name;
  private final int age;
  public static scala.Function1<scala.Tuple2<java.lang.String, java.lang.Object>
, cn.scala.xtwy.B> tupled();
  public static scala.Function1<java.lang.String, scala.Function1<java.lang.Obje
ct, cn.scala.xtwy.B>> curried();
  public java.lang.String name();
  public int age();
  public cn.scala.xtwy.B copy(java.lang.String, int);
  public java.lang.String copy$default$1();
  public int copy$default$2();
  public java.lang.String productPrefix();
  public int productArity();
  public java.lang.Object productElement(int);
  public scala.collection.Iterator<java.lang.Object> productIterator();
  public boolean canEqual(java.lang.Object);
  public int hashCode();
  public java.lang.String toString();
  public boolean equals(java.lang.Object);
  public cn.scala.xtwy.B(java.lang.String, int);
}


//自己主动生成的伴生对像类
public final class cn.scala.xtwy.B$ extends scala.runtime.AbstractFunction2<java
.lang.String, java.lang.Object, cn.scala.xtwy.B> implements scala.Serializable {

  public static final cn.scala.xtwy.B$ MODULE$;
  public static {};
  public final java.lang.String toString();
  public cn.scala.xtwy.B apply(java.lang.String, int);
  public scala.Option<scala.Tuple2<java.lang.String, java.lang.Object>> unapply(
cn.scala.xtwy.B);
  private java.lang.Object readResolve();
  public java.lang.Object apply(java.lang.Object, java.lang.Object);
  private cn.scala.xtwy.B$();
}

case object CaseObject相应的反编译后的内容：

                D:\ScalaWorkspace\ScalaChapter15\bin\cn\scala\xtwy>javap -private CaseObject.cla
ss
Compiled from "CaseObject.scala"
publicfinalclasscn.scala.xtwy.CaseObject {publicstatic java.lang.String toString();
  publicstaticinthashCode();
  publicstaticbooleancanEqual(java.lang.Object);
  publicstatic scala.collection.Iterator<java.lang.Object> productIterator();
  publicstatic java.lang.Object productElement(int);
  publicstaticintproductArity();
  publicstatic java.lang.String productPrefix();
}


D:\ScalaWorkspace\ScalaChapter15\bin\cn\scala\xtwy>javap -private CaseObject$.cl
ass
Compiled from "CaseObject.scala"
publicfinalclasscn.scala.xtwy.CaseObject$ extendscn.scala.xtwy.Aimplementsscala.Product,scala.Serializable {publicstaticfinal cn.scala.xtwy.CaseObject$ MODULE$;
  publicstatic {};
  public java.lang.String productPrefix();
  publicintproductArity();
  public java.lang.Object productElement(int);
  public scala.collection.Iterator<java.lang.Object> productIterator();
  publicbooleancanEqual(java.lang.Object);
  publicinthashCode();
  public java.lang.String toString();
  private java.lang.Object readResolve();
  private cn.scala.xtwy.CaseObject$();
}

对照上述代码不难看出。case object与case class所不同的是。case object相应反编译后的CaseObject$.cl
ass中不存在apply、unapply方法，这是由于None不须要创建对象及进行内容提取。从这个角度讲，它被定义为case object是十分合理的。

加入公众微信号，能够了解很多其它最新Spark、Scala相关技术资讯
技术分享

原文：http://www.cnblogs.com/cxchanpin/p/7112666.html

内容总结

以上是互联网集市为您收集整理的Scala入门到精通——第十五节 Case Class与模式匹配（二）全部内容，希望文章能够帮你解决Scala入门到精通——第十五节 Case Class与模式匹配（二）所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1118717.html

来源：【匿名】

【上一篇】scala中的特殊符号:下划线_【下一篇】php中is_scalar如何判断变量是否是一个标量

更多 ►

【Scala入门到精通——第十五节 Case Class与模式匹配（二）】教程文章相关的互联网学习教程文章

Scala入门到精通——第十七节类型参数（一）【代码】【图】

本节主要内容类型变量界定(Type Variable Bound)视图界定（View Bound)上界（Upper Bound）与下界（Lower Bound）1. 类型变量界定(Type Variable Bound)类型变量界定是指在泛型的基础上，对泛型的范围进行进一步的界定，从而缩下泛型的具体范围，例如： //下面的类编译通不过//因为泛型T在编译的时候不能确定其具体类型//即并不是所有的类中都存在compareTo方法classTypeVariableBound {def compare[T](first:T,second:T)={if (fir...

Scala入门到精通——第十三节高阶函数【代码】【图】

本节主要内容高阶函数简介Scala中的常用高阶函数SAM转换函数柯里化偏函数1. 高阶函数简介高阶函数主要有两种：一种是将一个函数当做另外一个函数的参数（即函数参数）；另外一种是返回值是函数的函数。这两种在本教程的第五节函数与闭包中已经有所涉及，这里简单地回顾一下：（1）函数参数//函数参数，即传入另一个函数的参数是函数 //((Int)=>String)=>String scala> def convertIntToString(f:(Int)=>String)=f(4)convertIntTo...

Scala快速入门（四）——继承、接口【代码】

Scala快速入门（四）——继承、接口一、继承1.继承的概念：省略2.模板：class Person(n:String,a:Int) {var name:String=nvar age:Int=adef showInfo():Unit={println("学生信息如下")println("名字："+name)println("年龄："+age)} } class Student(n:String,a:Int) extends Person(n,a){def study():Unit={println(this.name+". Im learning scala. ")} }3.方法的重写直接在方法之前用override进行修饰案例：class OverRideTest ...

Scala入门到精通——第十五节 Case Class与模式匹配（二）【代码】【图】

本节主要内容模式匹配的类型for控制结构中的模式匹配option类型模式匹配1. 模式的类型1 常量模式object ConstantPattern{def main(args: Array[String]): Unit = {//注意，以下定义的是一个函数//函数的返回值利用的是模式匹配后的结果作为其返回值//还须要注意的是函数定义在main方法中//也即scala语言能够在一个函数中定义另外一个函数def patternShow(x:Any)=x match {case5 => "five"casetrue=>"true"case"test"=>"String"case...

[大数据从入门到放弃系列教程]在IDEA的Java项目里,配置并加入Scala,写出并运行scala的hello world【代码】【图】

[大数据从入门到放弃系列教程]在IDEA的Java项目里,配置并加入Scala,写出并运行scala的hello world原文链接:http://www.cnblogs.com/blog5277/p/8615984.html原文作者:博客园--曲高终和寡点击下面菜单查看大数据入门全部教程大数据从入门到放弃网址:http://www.cnblogs.com/blog5277/category/1179528.html**********************************分割***********************************其实按理说,Java项目是完全可以开发spark项目的...

Scala开发入门指南【图】

作者：chszs，转载需注明。博客主页：http://blog.csdn.net/chszs一、下载Scala当前Scala的最新版本为2.10.2版，Windows有两种发布包：1）Windows (zip archive) scala-2.10.2.zip2）Windows (msi) scala-2.10.2.msi此外还有一个工具：Scala tool support (zip) scala-tool-support-2.10.2.zip 但是Scala最方便的安装方式是通过IDE安装，目前支持Eclipse、NetBeans和Intellij...

Scala 函数入门之默认参数和带名参数【图】

Scala 默认参数在Scala中，有时我们调用某些函数时，不希望给出参数的具体值，而希望使用参数自身默认的值，此时就定义在定义函数时使用默认参数。 def sayHello(firstName: String, middleName: String = "William", lastName: String = "Croft") = firstName + " " + middleName + " " + lastName 如果给出的参数不够，则会从作往右依次应用参数 Scala 与 Java实现默认参数的区别Java：public void sayHello(String name, int a...

Scala IDEA安装配置入门HelloWorld【代码】

Scala IDEA安装入门ScalaScala（发音为/?skɑ?l?, ?ske?l?/）是一门多范式的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。Scala是一门以java虚拟机（JVM）为目标运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。 Scala 是一门多范式 (multi-paradigm) 的编程语言，Scala支持面向对象和函数式编程。Scala源代码(.scala)会被编译成Java字节码(.class)，然后运行于JVM之上，并可以调用现...

Scala编程入门---面向对象编程之Trait【代码】

Scala中Trait是一种特殊概念首先我们可以将Triat做为接口来使用，此时的Triat就与java中的接口非常相似在Triat中可以定义抽象方法，就与抽象类中的抽象方法一样，只要不给出具体的实现即可类可以使用extend是关键字来继承Triat，注意这里不是Implement，而是extends，在Scala中没有Implement的概念，无论是继承还是Triat都是extends类继承Triat后，必须实现其中的抽象方法，实现是不需要override关键字Scala不支持对类进行多继承，...

Scala入门到精通——第二十九节 Scala数据库编程【代码】【图】

本节主要内容Scala Mavenproject的创建Scala JDBC方式訪问MySQLSlick简单介绍Slick数据库编程实战SQL与Slick相互转换本课程在多数内容是在官方教程上改动而来的，官方给的样例是H2数据库上的。经过本人改造，用在MySQL数据库上，官方教程地址：http://slick.typesafe.com/doc/2.1.0/sql-to-slick.html1. Scala Mavenproject的创建本节的project项目採用的是Maven Project，在POM.xml文件里加入以下两个依赖就能够使用scala进行JDBC...

Scala 函数入门之过程、lazy值和异常

Scala 过程在Scala中，定义函数时，如果函数体直接包裹在了花括号里面，而没有使用=连接，则函数的返回值类型就是Unit。这样的函数就被称之为过程。过程通常用于不需要返回值的函数。过程还有一种写法，就是将函数的返回值类型定义为Unit。 def sayHello(name: String) = "Hello, " + name def sayHello(name: String) { print("Hello, " + name); "Hello, " + name } def sayHello(name: String): Unit = "Hello, " + name la...

1.Scala入门【图】

Scala: 一门多范式编程语言线上平台一.Scala特性面向对象函数式编程静态类型可扩展语言类型二.Scala语言入门 1.数据类型数据类型描述Int 32位有符号补码整数Float 32位 IEEE754单精度浮点数Double 32位 IEEE754双精度浮点数String 字符序列Boolean True/FalseUnit 同java void :无值,用在不返回任何结果的类型2.常量与变量常量定义方法 val 常量名:数据类型=内容 val 常量名=内容有声明类型定义无声明类型定义变量定义方法 ...

Scala入门到精通——第二十九节 Scala数据库编程【代码】【图】

><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.18</version></dependency><dependency><groupId>com.typesafe.slick</groupId><artifactId>slick_2.11</artifactId><version>2.1.0</version></dependency>scala IDE for eclipse 中创建scala Maven项目的方式如下：在Eclispe 中点击” File->new->other”，如下图输入Maven可以看到Maven Project: 直接next，得到再点击next，在filter...

Scala编程入门基础之OOP文档学习【代码】【图】

文章目录Scala类和对象1、构造器2、object类3、枚举4、模式匹配<1>、基本语法<2>、模式识别<3>、InstanceOf<4>、匿名方法5、Trait6、泛型7、型变<1>、协变<2>、逆变8、隐式转换 Scala类和对象类是对象的抽象，对象是类的实现，类是抽象的不占用内存，但对象是具体的内存放在堆里实现继承：重写加上@Override 子类重写超类抽象方法不需要用@Override 单一继承只有主构造函数才能往基类构造函数加函数Scala单例对象： Scala中没有...

Scala 入门3（类、Trait、模式匹配、正则、异常、提取器、IO）【代码】

文章目录 1. 类和对象2. Trait3. 模式匹配4. 正则5. 异常处理6. 提取器7. 文件 IO学自 https://www.runoob.com/scala/scala-tutorial.html 1. 类和对象 object myClass {import java.io._class Point(xc : Int, yc : Int){var x : Int = xcvar y : Int = ycdef move(dx:Int, dy:Int): Unit ={x += dxy += dyprintln("x : " + x)println("y : " + y)}}// 继承,只能单继承class Piont3D( val xc : Int, val yc : Int,val zc : Int) e...

首页 / SCALA / Scala入门到精通——第十五节 Case Class与模式匹配（二）

Scala入门到精通——第十五节 Case Class与模式匹配（二）

内容导读

内容图文

本节主要内容

1. 模式的类型

2. for控制结构中的模式匹配

3. Option类型模式匹配

内容总结

内容备注

内容手机端

【Scala入门到精通——第十五节 Case Class与模式匹配（二）】教程文章相关的互联网学习教程文章

SCALA - 相关标签

入门 - 相关标签

SCALA - 技术教程分类

SCALA - 最新教程

SCALA - 最热教程