精华内容
下载资源
问答
  • 类型匹配

    2009-03-19 20:14:00
    实参和形参存在一个类型匹配的过程,不同的类型匹配有不同的优先级:精确匹配>提升匹配>标准转换匹配>用户自定义转换匹配。以下分别说说这几种情况:1、精确匹配有左值转换匹配和限定符转换匹配两种,左值转换匹配又...

    实参和形参存在一个类型匹配的过程,不同的类型匹配有不同的优先级:精确匹配>提升匹配>标准转换匹配>用户自定义转换匹配。以下分别说说这几种情况:

    1、精确匹配

    有左值转换匹配和限定符转换匹配两种,左值转换匹配又分为:左值到右值、数组到指针、函数到指针。数组、函数都是类型,数组类型不是指针类型,函数类型也不是指针类型,但由于函数形参类型无数组、函数这来两种类型,因此存在数组到指针、函数到指针的转换。这些转换都属于精确匹配。限定符转换只作用在指针所指向对象,对于指针本身的限定符则不进行任何转换,当作完全一致匹配处理。限定符包含const、volatile。以下例子说明限定符转换:

    void ff(const int *);

    void f(int * const);

    int *p = NULL;

    f(p);//无限定符转换,一致匹配

    ff(p);//限定符转换,属于精确匹配

    2、提升匹配

    包括整值类型(char,unsigned short,short,int,unsigned int, long, unsigned long)间的提升、浮点类型间的提升、枚举类型或布尔型到int的提升。所有的提升都保证提升后的类型能够表示未提升前类型的所有值。

    3、标准转换匹配

    整值类型转换匹配、浮点类型转换匹配、浮点--整值类型转换匹配、指针转换匹配、布尔转换匹配。标准转换匹配不能保证数据的安全,即不能保证转换后不发生截断或精度损失情况。

    展开全文
  • 一、 模式匹配和样例类Scala一个十分强大的模式匹配机制,可以应用到很多场合:如switch语句、类型检查等。 并且Scala还提供了样例类,对模式匹配进行了优化,可以快速进行匹配 1. 匹配字符串package ...

    一、 模式匹配和样例类

    Scala有一个十分强大的模式匹配机制,可以应用到很多场合:如switch语句、类型检查等。
    并且Scala还提供了样例类,对模式匹配进行了优化,可以快速进行匹配
    1. 匹配字符串

    package cn.toto.scala.day2
    
    import scala.util.Random
    
    /**
      * Created by toto on 2017/6/30.
      */
    object CaseDemo extends App{
      var  arr = Array("zhangsan","lisi","wangwu")
      val name = arr(Random.nextInt(arr.length))
    
      name match {
        case "zhangsan" => println("zhangsan....")
        case "lisi" => println("lisi....")
        case "wangwu" => println("wangwu....")
        case _ => println("真不知道你们在说什么....")
      }
    }

    2. 匹配类型

    package cn.toto.scala.day2
    
    import scala.util.Random
    
    /**
      * Created by toto on 2017/7/1.
      * 匹配类型
      */
    object CaseDemo02 extends App {
    
      //val v = if(x >= 5) 1 else if(x < 2) 2.0 else "hello"
      //可以使用不同的类型,可以使用自己定义的类型
      val arr = Array("hello",1,2.0,CaseDemo)
      val v = arr(Random.nextInt(4))
      println(v)
      v match {
        case x:Int => println("Int " + x)
        case y:Double if(y >= 0) => println("Double " + y)
        case z:String => println("String " + z)
        case CaseDemo => {
          println("case demo")
        }
        case _ => {
          println("default")
        }
      }
    }

    运行的结果有以下几种情况:

    cn.toto.scala.day2.CaseDemo$@5f2050f6
    case demo
    
    2.0
    Double 2.0
    
    hello
    String hello
    
    1
    Int 1

    **注意:**case y: Double if(y >= 0) => …
    模式匹配的时候还可以添加守卫条件。如不符合守卫条件,将掉入case _中
    3. 匹配数组、List、元组

    package cn.toto.scala.day2
    
    /**
      * Created by toto on 2017/7/1.
      * 整个的运行结果是:
      * 匹配2,3开头的 5
      * ===========================
      * 3
      * List(-1)
      * ===========================
      * 3 List(-1)
      * 2,3 7
      */
    object CaseDemo3 extends App{
      var arr = Array(2,3,5)
      /**
        * 可以匹配数组中的一部分的内容
        */
      arr match {
        case Array(1, x, y) => println(x + " " + y)
        case Array(2,3,x) => println("匹配2,3开头的 " + x)
        case Array(0) => println("only 0")
        case Array(0, _*) => println("0 ...")
        case _ => println("something else")
      }
    
      println("===========================")
      val lst = List(3,-1)
      println(lst.head)
      println(lst.tail)
      println("===========================")
      //Nil表示空列表
      lst match {
        case 0 :: Nil => println("only 0")
        //运行结果是:3 List(-1)
        case 3 ::a => println(s"3 $a")
        //下满的结果是:x: 3 y: -1
        //case x :: y :: Nil => println(s"x: $x y: $y")   //注意要加个字符串s
        case 0 :: tail => println("0 ...")
        case _ => println("something else")
      }
    
      println("===========================")
      //下面的运行结果是:2,3 7
      //元组
      val tup = (2,3,7)
      tup match {
        case (1,x,y) => println(s"1,$x,$y")
        case (2,3,a) => println(s"2,3 $a")
        case (_,z,5) => println(z)
        case _=> println("else")
      }
    }

    注意:在Scala中列表要么为空(Nil表示空列表)要么是一个head元素加上一个tail列表。
    9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
    注意::: 操作符是右结合的,如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
    4. 样例类
    在Scala中样例类是一中特殊的类,可用于模式匹配。case class是多例的,后面要跟构造参数,case object是单例的

    package cn.toto.scala.day2
    
    import scala.util.Random
    
    /**
      * Created by toto on 2017/7/1.
      */
    case class SubmitTask(id: String, name: String)
    case class HeartBeat(time: Long)
    case object CheckTimeOutTask
    
    /**
      * 下面的結果分为一下几种情况:
      * 0001, task-0001
      *
      * check
      * 
      * 123333
      */
    object CaseDemo04 extends App {
      val arr =  Array(CheckTimeOutTask,HeartBeat(123333),SubmitTask("0001","task-0001"))
    
      arr(Random.nextInt(arr.length)) match {
        case SubmitTask(id,name) => {
          println(s"$id, $name")
        }
        case HeartBeat(time) => {
          println(time)
        }
        case CheckTimeOutTask => {
          println("check")
        }
      }
    }
    展开全文
  • 在Scala的模式匹配中,可以使用类型、通配符、序列、正则表达式,甚至可以深入获取对象的状态。这种对象状态的获取遵循一定的协议,也就是对象内部状态的可见性由该类型的实现来控制,这样我们就可以获取暴露的状态...

    在Scala的模式匹配中,可以使用类型、通配符、序列、正则表达式,甚至可以深入获取对象的状态。这种对象状态的获取遵循一定的协议,也就是对象内部状态的可见性由该类型的实现来控制,这样我们就可以获取暴露的状态并应用于变量中。对象的获取往往被称为“提取”或者“解构”。

    1、简单匹配

    简单匹配有点类似Java中的Switch语句,会匹配每一个确定的值。具体如下:

     def match_boolean(): Unit ={
        val bools = Seq(true,false)
        for(bool <- bools){
          bool match {
            case true => println("Got heads")
            case false => println("Got tails")
          }
        }
      }

    在上述代码中,首先创建了一个序列,针对每一个元素使用match匹配,其匹配可能性只存在true和false两种情况。这与大多数语言的模式匹配是一致的,当然一般开发中的匹配是比较复杂的,上述代码只是作为实例代码而已。

    2、match中的值、变量和类型

    Scala中,模式匹配可以使用值、变量、类型作为匹配内容。以下例子能匹配特定得某个值(与Java得switch相似),也可以匹配特定类型,如:判定是字符串、Double等。

    def match_any():Unit={
        for{x <- Seq(1,2,2.7,"one","two",'four)}{
          val str = x match {
            case 1  => "int 1" //匹配值为1的整数
            case i:Int => "other int: " + i //匹配非1的整形内容,将匹配项赋值给变量i
            case d: Double => "a double: " + x//匹配Double类型内容,将匹配项赋值给变量d
            case "one" => "string one"//匹配字符串为“one”
            case s: String => "other string:" + s//匹配除“one”的其他字符串
            case unexpected => "unexpected value:" + unexpected//除以上几种匹配的所以模式
          }
          println(str)
        }

    对于上边实例,只是为了演示模式匹配效果,并且可以将需要匹配内容直接赋值给另外一个变量。当然上述示例中没有任何意义,无论是i或者d都是与x相同。但是这种语法可以方便我们匹配Tuple类型等,可以直接将Tuple类型解析,如:case (v1:Int,v2:Int) => "v1:"+v1+",v2:"+v2这段代码代码表示,如果匹配项是一个Tuple2类型,那么将.1赋值给v1,将._2赋值给v2。这样就可以在后续表达式中直接使用v1、v2两个变量。当然对于上述示例,就不需要特意定义变量,可以直接使用占位符(““)即可。 具体代码如:

     def match_any():Unit={
        for{x <- Seq(1,2,2.7,"one","two",'four)}{
          val str = x match {
            case 1  => "int 1" //匹配值为1的整数
            case _:Int => "other int: " + _ //匹配非1的整形内容,将匹配项赋值给变量i
            case _: Double => "a double: " + x//匹配Double类型内容,将匹配项赋值给变量d
            case "one" => "string one"//匹配字符串为“one”
            case _: String => "other string:" + _//匹配除“one”的其他字符串
            case unexpected => "unexpected value:" + unexpected//除以上几种匹配的所以模式
          }
          println(str)
        }
      }

    到现在,我们接触的模式匹配都是使用静态量匹配,或者使用类型等。但是,在Scala中,我们可以使用已经定义的变量来匹配(这可能是一个很大的惊喜哦,在实际开发中,可以用来根据不同条件提取数据)。具体如:

      def match_variable(y:Int):Unit = {
        for {
          x <- Seq(99,100,101)
        }{
          val str = x match {
            case `y` => "found y!"//需要特别注意,这里不可以使用case y,必须用反引号来引用变量
            case _:Int =>s"int:$x"
          }
          println(str)
        }
      }

    我们首先通过函数参数传入变量y,然后在匹配中,引用y来与匹配项比较,如果匹配成功,则执行后续代码。需要特别注意,在使用变量匹配时,必须用反引号“`”来包围变量,如上例中“y”。
    像Java中,一般可能会针对多种匹配类型执行同样操作,我们一般会在最后一条满足条件的判断上写入需要执行的操作,然后break,如:

     switch (i){
                case 'a':
                case 'b':
                    System.out.println("print");
                    break;
            }

    Scala中也支持针对不同的匹配子句需要使用相同的处理代码的情况,而且代码逻辑更简单明了。

     x match {
          case 'a' | 'b' => println(x)
        }
    展开全文
  • scala三种匹配模式 基本模式匹配 模式守卫 类型匹配 注:匹配模式是从上往下匹配的,在后面的匹配中可能case之间调换位置,匹配结果就不一样。 基本模式匹配 传入什么基本就对相应元素元素进行匹配,输出匹配上...

    一、scala匹配模式

    scala有三种匹配模式

    1. 基本模式匹配
    2. 模式守卫
    3. 类型匹配

    注:匹配模式是从上往下匹配的,在后面的匹配中可能case之间调换位置,匹配结果就不一样。

    基本模式匹配

    传入什么基本就对相应元素元素进行匹配,输出匹配上的元素相应的输出。
    案例演示:

    def matchTest(x:Int):String=x match {
          case 1 => "one"
          case 2 => "two"
          case 3 => "three"
          case _ => "many"
        }
    
        println(matchTest(3))
        println(matchTest(2))
        println(matchTest(8))
      }
    

    模式守卫

    对于一般基本匹配模式,传入的x只能值一个值进行匹配,匹配上就输出相应的值。但是x只能一个一个值进行匹配,并不能匹配一个范围。但是在模式守卫中可以添加if条件,进行匹配的守卫,同时也可以圈定匹配范围。
    案例演示:

    def matchTest2(x:Int):String= x match {
          case i if i==100 => "满分大神"
          case i if i>=90 && i<100 =>"相当优秀"
          case i if i>=80 && i<90 => "良好"
          case i if i>=70 && i<80 => "一般"
          case i if i>=60 && i<70 => "及格"
          case i if i>=0 && i<60 => "不及格"
          case _ => "成绩不合法"
        }
    
        println(matchTest2(20))
    

    类型匹配

    scala匹配模式中也可以匹配传来数据的类型,判断数据类型匹配成功则输出相应值。
    案例演示:

    def matchTest03(x:Any):String = x match {
          case x:Int => "this is Int"
          case x:String => "this is String"
          case _ => "this is not Int and String"
        }
    
        println(matchTest03(2))
      }
    

    二、样例类

    样例类是在scala中经常用在模式匹配中,当一个类被定义成为case类后,Scala会自动帮你创建一个伴生对象并帮你实现了一系列方法且带来了不少好处。

    样例类的定义

    //定义一个样例类
        case class Students(name:String,age:Int)
    

    三、对样例类进行模式匹配

    def matchTest04(x:Students)=x match {
          case Students(name, age) => println(age)
          case Students(name, 19) => println(name)
          case Students("zs", age) => println(age)
          case _ => println("no matches")
        }
        //调用
        val stu1 = Students("zs",19)
        matchTest04(stu1)
        matchTest04(Students("Tom",15))
    

    四、普通类的模式匹配

    普通类要想进行模式匹配,需要创建对象,需要自己创建半生类,创建半生对象。使用unapply方法。才能进行模式匹配。
    案例演示:

    object MatchDemo01 {
      def main(args: Array[String]): Unit = {
        //非样例类的模式匹配,需要使用半生对象实现unplay方法
        def matchTest05(x:Student)=x match {
          case Student(name,age) if age<20 => println("young")
          case Student(name,age) if age>30 => println("old")
        }
    
        matchTest05(Student("zhangsan",18))
        matchTest05(Student("lisi",35))
      }
    }
    
    //定义一个普通的类
    class Student(n:String,a:Int){
      //定义一下成员变量
      var name:String=n
      var age:Int=a
    }
    
    object Student{
      def apply(n: String, a: Int): Student = new Student(n, a)
    
      def unapply(arg: Student): Option[(String, Int)] = {
        //实现提取器的逻辑代码
        if(arg==null) None else Some(arg.name,arg.age)
      }
    }
    
    展开全文
  • excel Match函数不同匹配类型用法解析

    千次阅读 2021-01-25 16:15:22
    通俗说法:MATCH(要查找相对位置的指定值,搜索区域,匹配类型) 第一个参数lookup_value可以是数字、文本或逻辑值,或者对上述类型的引用; 第二个参数lookup_array( 搜索区域)必须为同行或同列; 第三个参数...
  • 正则表达式匹配数值类型字符串

    千次阅读 2016-04-08 16:36:54
    匹配数值类型字符串的正则表达式 public class Test { public static void main(String[] args) { String reg = "^-?([1-9]\\d*|0)(\\.\\d+)?$"; System.out.println("123456789".matches(reg)); System.out....
  • 判断变量类型是否匹配 如:int a; char b; 如何写代码判断a和b的类型是否一样
  • [scala基础]--类型匹配

    2017-01-03 18:02:24
    在运行时决定数据类型,所以经常在类型匹配中使用Some来匹配类型。如果不添加Some匹配,会导致结果不是我们想要的。1、比如Map集合:val strMap=("123"-&gt;"tom","456"-&...
  • 二分图最大匹配: 问题描述:给出一个二分图,找一个边数最大的匹配。就是选择尽量多的边,使得选中的边中任意两条边均没有公共点。如果所有的点都是匹配点那就是一个完美匹配。 解决方案:增广路定理 增广路:从...
  • scala 的模式匹配类型系统

    千次阅读 2016-07-23 15:10:15
    主要内容: 1. scala模式匹配 2. scala类型系统
  • 我看图像匹配有基于特征的匹配和基于区域(模板)的匹配 那基于形状的匹配属于哪种呢?要用到边缘,边缘属于特征吧,所以是基于特征的吗?
  • 比如:后台设置关键词【公众号类型】,客户只有输入【公众号类型】时才会触发,而输入【公众号的类型】【公众号类型有哪些】【类型公众号】都不会触发。 图片 02 半匹配匹配是指客户输入的关键词,必须完全包含...
  • MySQL 数据类型匹配 报错

    千次阅读 2018-08-16 16:08:18
    DAO层更改数据库数据时,抛异常 控制台报错:Unable TO ...仔细跟踪一下debug,就可以查出哪一个字段传入的值与在数据库中定义的字段类型匹配,该问题通常是传入的数值长度超过了数据库中定义的字段类型长度。...
  • 映射表如下:下面就举个例子来讲(JAVA插入MySql的datetime类型的简单的例子):看了映射表可知:我们可以以Timestamp类型的值插入到数据库中数据库中表的设计为这样(两个字段,id为整型是主键,create_on为...
  • Mysql字段和java实体类属性类型匹配

    千次阅读 2019-06-19 15:59:13
    Mysql字段和java实体类属性类型匹配 参见下图:
  • switch–case 能匹配的数据类型
  • SQL如何判断LIKE(模式匹配类型

    千次阅读 2017-01-23 16:36:51
    SQL中可以使用LIKE实现模式匹配,以%作为通配符语法: (1)'keywords%'以keywords开头 (2)'%keywords'以keywords结尾 (3)'%keywords%'任意位置含有keywords 遇到一个需求,不但要找出模式匹配的子集合,...
  • C++ 输入类型匹配检测方法

    千次阅读 2013-07-16 10:59:55
    今天看C++ primer plus一书,看到C++中检测输入类型匹配的检测方法。 输入类型匹配是指输入的数据类型与所期望的类型匹配,如 int n; cin >> n; 但输入的数据为字符串时,这种 情况就是输入类型匹配。那么...
  • Scala-模式匹配

    千次阅读 2020-08-30 22:58:14
    三、 模式匹配类型 3.1 匹配常量 3.2 匹配类型 3.3 匹配数组 3.4 匹配列表 3.5 匹配元组 3.6 匹配对象及样例类 四、 变量声明中的模式匹配 五、 for表达式中的模式匹配 六、 偏函数中的模式匹配(了解) ...
  • scala不仅对值,而且可以对类型,集合(map,list元数据匹配),object,class scala大量使用模式匹配(match case)Scala的模式匹配,与Java的switch case的区别:1.不仅可以匹配值,可以匹配类型2.可以匹配数组的...
  • 正则表达式,匹配文件名类型

    千次阅读 2015-10-14 14:16:57
    匹配C语言文件名后缀 使用方法一: find * * | grep -E "\.c$|\.h$" 说明:查找文件中后缀为.c,.h者。 使用方法二: diff -x "[^(\.(c|cpp|h|inc)$)]" test/ test2/ 说明:比较目录test/和目录...
  • 类型匹配;‘dimyouranswer' ![求大神指点 图片说明](https://img-ask.csdn.net/upload/201811/22/1542890980_165272.jpg)
  • 模板匹配

    千次阅读 2018-04-03 09:40:37
    u 匹配方法的类型通过所包含像素的灰度值关系描述模型的方法:l 经典gray-value-based matching基于灰度值匹配,只在非常少的情况下使用,只能在光照可以变量化的情况下使用。l 更加强大的correlation-based ...
  • Access 标准表达式中数据类型匹配

    千次阅读 2014-05-08 10:08:02
    Access 标准表达式中数据类型匹配 Access标准表达式中数据类型匹配 今天在做一个小程序时,要求用到Access数据库,在调试运行一个SELECT语句时,老是提示标准表达式中数据类型匹配,弄了好久,原来发现是数据...
  • C语言中实参和形参的类型匹配

    千次阅读 2021-01-08 11:32:50
    #include <...对于参数类型的不匹配一个解释是:函数调用时,将实参的值传递给形参,系统首先会自动隐式地把实参的值的类型转换为形参的类型,然后再赋值给形参。 对于缺少被调函数的类型说明,但程序依
  • 在众多 Swift 提供给 Objective-C 程序员使用的新特性中,个特性把自己伪装成一个无聊的老头,但是却在如何优雅滴解决“鞭尸金字塔“的问题上有着巨大的潜力。很显然我所说的这个特性就是 switch 语句, 对于很多 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,147,088
精华内容 458,835
关键字:

匹配的种类有哪些