scala正则表达式_scala 正则表达式 - CSDN
精华内容
参与话题
  • scala正则表达式基础

    2018-05-09 10:23:25
    --------------------------目录--------------------------1、正则表达式阐述2、scala正则表达式基础---------------------------------------------------------1、正则表达式阐述正则表达式是对字符串操作的一种...
    --------------------------目录--------------------------
    1、正则表达式阐述
    2、scala正则表达式基础
    ---------------------------------------------------------


    1、正则表达式阐述
    正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组
    成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。给定一个正则表达式和另一个字符串
    ,我们可以达到如下的目的:

    1. 给定的字符串是否符合正则表达式的过滤逻辑(称作“匹配”);
    2. 可以通过正则表达式,从字符串中获取我们想要的特定部分。

    每一次的正则表达式编译都是非常昂贵的,所以一般是先写好放在外部
    创建一个正则表达式的典型方法是通过使用方法(后面加".r"),这对字符串提供了隐式的转换方法,如下:
    [java] view plain copy
    1. val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r  








    2、scala正则表达式基础

    object regexTest {
      def findWords(content: String): List[String] =
        ("hello".r findAllIn content).toList
    
      def main(args: Array[String]) {
        val a1 = "hello, i am LEGOTIME ,my blog site is http://blog.csdn.net/legotime,hello everyone!!  ?"
    
        //---------------------------匹配单个字符串--------------------------------------------
        /**
          * 匹配单个字符
          *  findAllIn  :全部匹配出来
          *  findFirstIn  : 匹配第一个
          */
        val p1 = """hello""".r   //"hello".r  ,也可以
        //val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
        println(p1 findAllIn a1 toList)   //List(hello, hello)
        println(p1 findFirstIn a1 toList)   //List(hello)
    
        /**
          * 匹配任意字符串
          *   .   :英文中的句号,可以匹配任意一个单个的字符,可以使用n个 点  来匹配n个字符,同时可以出现在不同位置
          */
    
        val p2 = ".g.".r
        println(p2 findAllIn a1 toList)   //List(og , og., ego)
        println(p2 findFirstIn a1 toList)   //List(og )
    
        /**
          * 匹配特殊字符
          *   \   :转意字符  ,前面加這个 表示有特殊的含义
          */
    
        val  p3 = """.g\.""".r
        println(p3 findAllIn a1 toList)   //List(og.)
    
        val p4 = """/""".r
        println(p4 findAllIn a1 toList)   //List(/, /, /)
    
    
        //---------------------------匹配一组字符串--------------------------------------------
        val a2 = "<div id=\"yui3-css-stamp\" style=\"position: absolute !important; visibility: hidden !important\" class=\"\"></div>" +
          "body, Div, dl, dt, dd, ul, ol, li, h1, h2, h3, h4, h5, h6, pre, code, form, fieldset, legend, input, textarea, p, blockquote, th, td"
        val p5 = """.i.""".r
        println(p5 findAllIn a2 toList)   //List(div,  id, ui3, sit, !im, vis, bil, hid, !im, div, Div, li,, fie,  in)
    
        /**
          * 匹配多个字符串中的某一些
          *   []    : 把需要匹配的字符放到中括号里面,注意是区分大小写
          */
        val p6 = """[bd]i.""".r
        println(p6 findAllIn a2 toList)   //List(div, bil, div)
    
        /**
          * 匹配一个范围中的某一些
          *   -   : 连接符(-)左边是起始,右边是结束。特别注意 右边必须大于左边
          *
          *   [0-9]:匹配从0到9的数字    等价于  \d
          *   [a-z]:匹配从a到z的字符
          *   [A-Z]:匹配从A到Z的字符
          *   [A-z]:匹配从A到z的字符、符号等(内部还有其他一些出字母的符号)
          *   [0-9A-Za-z]:匹配数字和字符
          */
        val p7 =  """.h[0-3]""".r
        println(p7 findAllIn a2 toList)   //List( h1,  h2,  h3)
    
        /**
          * 用非(^)匹配一些不要的字符
          *   ^    :元字符 ^ 表示非
          */
    
        val p8 =  """.h[^0-2]""".r
        println(p8 findAllIn a2 toList)   //List( hi,  h3,  h4,  h5,  h6, th,)
    
        //---------------------------使用元字符简写--------------------------------------------
    
        /**
          * [0-9]:匹配从0到9的数字     等价于  \d
          * [^0-9]:匹配非从0到9的数字    等价于  \D
          * [a-zA-Z0-9_]:匹配数字、字符和下划线(_)        等价于   \w
          * [^a-zA-Z0-9_]:匹配非数字、字符和下划线(_)        等价于   \W (大写)
          *
          */
        val p9 =  """.h\d""".r
        println(p9 findAllIn a2 toList)   //List( h1,  h2,  h3,  h4,  h5,  h6)
        val p10 =  """.h\D""".r
        println(p10 findAllIn a2 toList)   //List( hi, th,)
        val p11 =  """.h\w""".r
        println(p11 findAllIn a2 toList)   //List( hi,  h1,  h2,  h3,  h4,  h5,  h6)
        val p12 =  """.h\W""".r
        println(p12 findAllIn a2 toList)   //List(th,)
    
        //---------------------------重复匹配--------------------------------------------
        /**
          * 有的时候,我们可以用  +   来进行最少一个的多次重复匹配,
          */
        val a3 = "p123,156p78,14w89ew10,pw156  ?+"
    
        val p13 = """\d""".r
        println(p13 findAllIn a3 toList)   //List(1, 2, 3, 1, 5, 6, 7, 8, 1, 4, 8, 9, 1, 0, 1, 5, 6)
        //使用  +  来进行 多次重复匹配
        val p14 = """\d+""".r
        println(p14 findAllIn a3 toList)   //List(123, 156, 78, 14, 89, 10, 156)
        val p15 = """\d+[a-z]""".r
        println(p15 findAllIn a3 toList)   //List(156p, 14w, 89e)
        val p16 = """\d+[a-z]+""".r
        println(p16 findAllIn a3 toList)   //List(156p, 14w, 89ew)
    
        /**
          *  有时候我们希望匹配到 0次的情况,那么 + 就达不到要求,
          *  我们可以使用   *    来进行匹配 0次或多次,就是 比 + 多一个  0 次的范围
          */
        val p17 = """\d*[a-z]+""".r
        println(p17 findAllIn a3 toList)   //List(p, 156p, 14w, 89ew, pw)
    
        /**
          *  ?  :匹配0个或1个
          */
        val p18 = """\d?[a-z]+""".r
        println(p18 findAllIn a3 toList)   //List(p, 6p, 4w, 9ew, pw)
    
        /**
          * {n}  : 匹配指定个数 n
          */
    
        val p19 = """\d{2}[a-z]+""".r
        println(p19 findAllIn a3 toList)   //List(56p, 14w, 89ew)
    
        /**
          * {m,n}  : 匹配指定的一个范围   m到n 个   包含 m,n
          */
        val p20 = """\d{0,1}[a-z]+""".r
        println(p20 findAllIn a3 toList)   //List(p, 6p, 4w, 9ew, pw)
    
        //---------------------------位置匹配--------------------------------------------
        val a4 = "The cat scattered his food all over the room"
    
    
        val p21 = """cat""".r
        println(p21 findAllIn a4 toList)   //List(cat, cat)
    
        /**
          *  \b  :用来匹配一个单词开始或者结束
          *  \B  :不匹配一个单词边界
          */
    
        val p22 = """\bcat\b""".r
        println(p22 findAllIn a4 toList)   //List(cat)
    
        val p23 = """cat\b""".r
        println(p23 findAllIn a4 toList)   //List(cat)
        val p24 = """\bcat""".r
        println(p24 findAllIn a4 toList)   //List(cat)
    
        //---------------------------子表达式--------------------------------------------
    
        /**
          * ()  :内部的内容就作为一个子式  常与  (){n}一起使用
          */
        val a5 = "my Ip is 192.168.58.10"
    
        val p25 = """(\d{1,3}\.){3}\d{1,3}""".r
        println(p25 findAllIn a5 toList)   //List(192.168.58.10)
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
      }
    }
    

    参考文献
    https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html?is-external=true
    http://baike.baidu.com/link?url=ksRyhmGLTGNTVULyqQlyoSojcT8rsmoNQU09GkXT7fp7Neleml2NKHFM77sA_mDH3NeP_mUfDLoRF4W-Y9fkAq
    <正则表达式 必知必会>
    展开全文
  • Scala教程(九)正则表达式

    千次阅读 2015-09-23 17:49:13
    什么是正则表达式:在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。正则表达式规定的一个特殊...

      


    Scala教程()正则表达式

     


    1 正则表达式

    1.1 什么是正则表达式


      在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。

      正则表达式规定的一个特殊代码叫作它元字符(metacharacter)

     

    常用的元字符 

    代码

    说明

    .

    匹配除换行符以外的任意字符

    \w

    匹配字母或数字或下划线或汉字

    \s

    匹配任意的空白符

    \d

    匹配数字

    \b

    匹配单词的开始或结束

    ^

    匹配字符串的开始

    $

    匹配字符串的结束

     

    1.2 字符转义

      如果你想查找元字符本身的话,比如你查找.,或者*,就出现了问题:你没办法指定它们,因为它们会被解释成别的意思。这时你就得使用\来取消这些字符的特殊意义。因此,你应该使用\.\*。当然,要查找\本身,你也得用\\.例如:deerchao\.net匹配deerchao.netC:\\Windows匹配C:\Windows

     

    常用的限定符 

    代码/语法

    说明

    *

    重复零次或更多次

    +

    重复一次或更多次

    ?

    重复零次或一次

    {n}

    重复n

    {n,}

    重复n次或更多次

    {n,m}

    重复nm

     

    1.3 分组

      分组:用小括号来指定子表达式。

       (\d{1,3}\.){3}\d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式,请按下列顺序分析它:\d{1,3}匹配13位的数字,(\d{1,3}\.){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次,最后再加上一个一到三位的数字(\d{1,3})

    IP地址中每个数字都不能大于255.

      不幸的是,它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话,或许能简单地解决这个问题,但是正则表达式中并不提供关于数学的任何功能,所以只能使用冗长的分组,选择,字符类来描述一个正确的IP地址:((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)

     

    1.4 反义

      有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外,其它任意字符都行的情况,这时需要用到反义:

     

    常用的反义代码

    代码/语法

    说明

    \W

    匹配任意不是字母,数字,下划线,汉字的字符

    \S

    匹配任意不是空白符的字符

    \D

    匹配任意非数字的字符

    \B

    匹配不是单词开头或结束的位置

    [^x]

    匹配除了x以外的任意字符

    [^aeiou]

    匹配除了aeiou这几个字母以外的任意字符

     

    1.5 贪婪与懒惰

      当正则表达式中包含能接受重复的限定符时,通常的行为是(在使整个表达式能得到匹配的前提下)匹配尽可能多的字符。以这个表达式为例:a.*b,它将会匹配最长的以a开始,以b结束的字符串。如果用它来搜索aabab的话,它会匹配整个字符串aabab。这被称为贪婪匹配。

    有时,我们更需要懒惰匹配,也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式,只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复,但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧:

    a.*?b匹配最短的,以a开始,以b结束的字符串。如果把它应用于aabab的话,它会匹配aab(第一到第三个字符)和ab(第四到第五个字符)。

     

    懒惰限定符

    代码/语法

    说明

    *?

    重复任意次,但尽可能少重复

    +?

    重复1次或更多次,但尽可能少重复

    ??

    重复0次或1次,但尽可能少重复

    {n,m}?

    重复nm次,但尽可能少重复

    {n,}?

    重复n次以上,但尽可能少重复

     

    1.6 网上的资源及本文参考文献


     精通正则表达式(第3版)

     微软的正则表达式教程

     System.Text.RegularExpressions.Regex(MSDN)

     专业的正则表达式教学网站(英文)

     关于.Net下的平衡组的详细讨论(英文)

     

    2 Scala中的正则表达式


    2.1 声明正则表达式变量

        // 定义正则表达式:匹配符合数字和小字字母
        val regex = """([0-9+] (a-z)+)""".r;

    2.2 正则表达式匹配数字

        val numPattern = "[0-9]+".r    
        // findAllIn方法找到line中所有符合正则的字符串,可以通过toArray方法来将匹配到的结果存放到Array中。for循环中,遍历出符合条件的匹配。
        for(matchString <-numPattern.findAllIn("99345 Scala 22298 Spark")){
            println(matchString);
        }; 
    


      输出结果:99345

                 22298

    2.3 正则表达式匹配赋值

        // findFirstIn只匹配第一个符合正则的字符串就停止了:
        val numberPattern = """\s+[0-9]+\s""".r
        println(numberPattern.findFirstIn("99ss java 22 hadoop storm")) 
    

      输出结果:Some( 22 )


    2.4 case多级匹配

        //  case中使用正则匹配
        val line = "3999ss spark"
        line match {
            case numitemPattern(num,blog) => println("num="+num+",blog="+blog) 
            case _=> println("no case...")
        }
    
     

     输出结果:no case...

     

     

        --以上为Scala正则表达式的内容,谢谢大家对我的关注。

                                                                                                                                                                                          ——厚积薄发(yuanxw)



    展开全文
  • Scala正则表达式

    2018-12-29 16:12:46
    Scala正则表达式继承了 Java 的语法规则,Java 则大部分使用了 Perl 语言的规则。 下表我们给出了常用的一些正则表达式规则: 表达式 匹配规则 ^ 匹配输入字符串开始的位置。 $ 匹配输入字符串结尾的位置。 . ...

    Scala 的正则表达式继承了 Java 的语法规则,Java 则大部分使用了 Perl 语言的规则。

    下表我们给出了常用的一些正则表达式规则:

    表达式 匹配规则
    ^ 匹配输入字符串开始的位置。
    $ 匹配输入字符串结尾的位置。
    . 匹配除"\r\n"之外的任何单个字符。
    […] 字符集。匹配包含的任一字符。例如,"[abc]“匹配"plain"中的"a”。
    [^…] 反向字符集。匹配未包含的任何字符。例如,"[^abc]“匹配"plain"中"p”,“l”,“i”,“n”。
    \A 匹配输入字符串开始的位置(无多行支持)
    \z 字符串结尾(类似$,但不受处理多行选项的影响)
    \Z 字符串结尾或行尾(不受处理多行选项的影响)
    re* 重复零次或更多次
    re+ 重复一次或更多次
    re? 重复零次或一次
    re{ n} 重复n次
    re{ n,}
    re{ n, m} 重复n到m次
    a|b 匹配 a 或者 b
    (re) 匹配 re,并捕获文本到自动命名的组里
    (?: re) 匹配 re,不捕获匹配的文本,也不给此分组分配组号
    (?> re) 贪婪子表达式
    \w 匹配字母或数字或下划线或汉字
    \W 匹配任意不是字母,数字,下划线,汉字的字符
    \s 匹配任意的空白符,相等于 [\t\n\r\f]
    \S 匹配任意不是空白符的字符
    \d 匹配数字,类似 [0-9]
    \D 匹配任意非数字的字符
    \G 当前搜索的开头
    \n 换行符
    \b 通常是单词分界位置,但如果在字符类里使用代表退格
    \B 匹配不是单词开头或结束的位置
    \t 制表符
    \Q 开始引号:\Q(a+b)*3\E 可匹配文本 “(a+b)*3”。
    \E 结束引号:\Q(a+b)*3\E 可匹配文本 “(a+b)*3”。

    正则表达式实例
    . 匹配除"\r\n"之外的任何单个字符。
    [Rr]uby 匹配 “Ruby” 或 “ruby”
    rub[ye] 匹配 “ruby” 或 “rube”
    [aeiou] 匹配小写字母 :aeiou
    [0-9] 匹配任何数字,类似 [0123456789]
    [a-z] 匹配任何 ASCII 小写字母
    [A-Z] 匹配任何 ASCII 大写字母
    [a-zA-Z0-9] 匹配数字,大小写字母
    [^aeiou] 匹配除了 aeiou 其他字符
    [^0-9] 匹配除了数字的其他字符
    \d 匹配数字,类似: [0-9]
    \D 匹配非数字,类似: [^0-9]
    \s 匹配空格,类似: [ \t\r\n\f]
    \S 匹配非空格,类似: [^ \t\r\n\f]
    \w 匹配字母,数字,下划线,类似: [A-Za-z0-9_]
    \W 匹配非字母,数字,下划线,类似: [^A-Za-z0-9_]
    ruby? 匹配 “rub” 或 “ruby”: y 是可选的
    ruby* 匹配 “rub” 加上 0 个或多个的 y。
    ruby+ 匹配 “rub” 加上 1 个或多个的 y。
    \d{3} 刚好匹配 3 个数字。
    \d{3,} 匹配 3 个或多个数字。
    \d{3,5} 匹配 3 个、4 个或 5 个数字。
    \D\d+ 无分组: + 重复 \d
    (\D\d)+/ 分组: + 重复 \D\d 对
    ([Rr]uby(, )?)+ 匹配 “Ruby”、“Ruby, ruby, ruby”,等等

    注意上表中的每个字符使用了两个反斜线。这是因为在 Java 和 Scala 中字符串中的反斜线是转义字符。所以如果你要输出 ..,你需要在字符串中写成 .\. 来获取一个反斜线。查看以下实例:

    import scala.util.matching.Regex
    
    object Test {
       def main(args: Array[String]) {
          val pattern = new Regex("abl[ae]\\d+")
          val str = "ablaw is able1 and cool"
          
          println((pattern findAllIn str).mkString(","))
       }
    }
    

    执行以上代码,输出结果为:

    $ scalac Test.scala 
    $ scala Test
    able1
    
    展开全文
  • Scala正则表达式

    千次阅读 2018-09-30 17:12:01
    Scala正则表达式继承了 Java 的语法规则,Java 则大部分使用了 Perl 语言的规则。下表是常用的一些正则表达式规则: 表达式 匹配规则 ^ 匹配输入字符串开始的位置。 $ 匹配输入字符串结尾的位置。 ...

     

     

    正则表达式

    Scala 的正则表达式继承了 Java 的语法规则,Java 则大部分使用了 Perl 语言的规则。下表是常用的一些正则表达式规则:

    表达式 匹配规则
    ^ 匹配输入字符串开始的位置。
    $ 匹配输入字符串结尾的位置。
    . 匹配除"\r\n"之外的任何单个字符。
    [...] 字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a"。
    [^...] 反向字符集。匹配未包含的任何字符。例如,"[^abc]"匹配"plain"中"p","l","i","n"。
    \\A 匹配输入字符串开始的位置(无多行支持)
    \\z 字符串结尾(类似$,但不受处理多行选项的影响)
    \\Z 字符串结尾或行尾(不受处理多行选项的影响)
    re* 重复零次或更多次
    re+ 重复一次或更多次
    re? 重复零次或一次
    re{ n} 重复n次
    re{ n,}
    re{ n, m} 重复n到m次
    a|b 匹配 a 或者 b
    (re) 匹配 re,并捕获文本到自动命名的组里
    (?: re) 匹配 re,不捕获匹配的文本,也不给此分组分配组号
    (?> re) 贪婪子表达式
    \\w 匹配字母或数字或下划线或汉字
    \\W 匹配任意不是字母,数字,下划线,汉字的字符
    \\s 匹配任意的空白符,相等于 [\t\n\r\f]
    \\S 匹配任意不是空白符的字符
    \\d 匹配数字,类似 [0-9]
    \\D 匹配任意非数字的字符
    \\G 当前搜索的开头
    \\n 换行符
    \\b 通常是单词分界位置,但如果在字符类里使用代表退格
    \\B 匹配不是单词开头或结束的位置
    \\t 制表符
    \\Q 开始引号:\Q(a+b)*3\E 可匹配文本 "(a+b)*3"。
    \\E 结束引号:\Q(a+b)*3\E 可匹配文本 "(a+b)*3"。

    正则表达式实例

    实例 描述
    . 匹配除"\r\n"之外的任何单个字符。
    [Rr]uby 匹配 "Ruby" 或 "ruby"
    rub[ye] 匹配 "ruby" 或 "rube"
    [aeiou] 匹配小写字母 :aeiou
    [0-9] 匹配任何数字,类似 [0123456789]
    [a-z] 匹配任何 ASCII 小写字母
    [A-Z] 匹配任何 ASCII 大写字母
    [a-zA-Z0-9] 匹配数字,大小写字母
    [^aeiou] 匹配除了 aeiou 其他字符
    [^0-9] 匹配除了数字的其他字符
    \\d 匹配数字,类似: [0-9]
    \\D 匹配非数字,类似: [^0-9]
    \\s 匹配空格,类似: [ \t\r\n\f]
    \\S 匹配非空格,类似: [^ \t\r\n\f]
    \\w 匹配字母,数字,下划线,类似: [A-Za-z0-9_]
    \\W 匹配非字母,数字,下划线,类似: [^A-Za-z0-9_]
    ruby? 匹配 "rub" 或 "ruby": y 是可选的
    ruby* 匹配 "rub" 加上 0 个或多个的 y。
    ruby+ 匹配 "rub" 加上 1 个或多个的 y。
    \\d{3} 刚好匹配 3 个数字。
    \\d{3,} 匹配 3 个或多个数字。
    \\d{3,5} 匹配 3 个、4 个或 5 个数字。
    \\D\\d+ 无分组: + 重复 \d
    (\\D\\d)+/ 分组: + 重复 \D\d 对
    ([Rr]uby(, )?)+ 匹配 "Ruby"、"Ruby, ruby, ruby",等等
    • Demo

    def main(args: Array[String]): Unit = {
    
        val pattern0 = "Scala".r
        val pattern1 = new Regex("(S|s)cala")
        val pattern2 = "^[A-Za-z0-9,]{1,64}".r
        val pattern3 = new Regex("abl[ae]\\d+")
    
        val str = "Scala, hello scala, ablaw is able123 and cool 11112222"
        println(pattern0.findAllIn(str).next())
        println(pattern1.findAllIn(str).mkString(","))
        println(pattern1.replaceAllIn(str, "Java"))
        println(pattern2.findAllIn(str).next())
        println(pattern3.findAllIn(str).mkString(":"))
    
      }

     

    展开全文
  • 文章作者:梦家 个人站点:dreamhomes.top ...公众号ID:DreamHub ...Scala 通过 scala.util.matching 包中的 Regex 类来支持正则表达式。 // 使用正则表达式查找单词 Scala val pattern = "Scala".r val str = "Scala.
  • scala正则表达式(一)基础匹配

    万次阅读 多人点赞 2016-08-02 20:29:39
    正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组 成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。给定一个正则表达式和另一个字符...
  • scala正则表达式

    千次阅读 2019-02-17 21:09:00
    Scala 通过 scala.util.matching 包中的 Regex 类来支持正则表达式。 eg:使用正则表达式查找单词 Scala  实例中使用 String 类的 r() 方法构造了一个Regex对象。(也可直接new一个Regex对象实例)  然后...
  • scala 正则表达式

    千次阅读 2020-09-20 19:38:14
    现在就简单总结一下scala中常见的正则表达式用法。如果有对正则表达式不熟悉的同志们,可以查看正则表达式30分钟入门教程。1.匹配电话号码匹配电话号码是我们常见的需求之一。代码如下: def reg() = { val PH
  • 10 scala 正则表达式

    2018-05-24 10:37:29
    scala 正则表达式RegExpressOps object RegExpressOps { def main(args: Array[String]): Unit = { val regex="""([0-9]+) ([a-z]+)""".r val numPattern = "[0-9]+"...
  • 前言 这是面向初学者的Scala教程的第5部分。... 这篇文章是有关正则表达式(regexes)的两个文章中的第一篇,正则表达式对于广泛的编程任务,尤其是计算语言学任务至关重要。 本教程介绍了如何在Scala中使用它们,...
  • Scala正则表达式提取文档中任意数字

    千次阅读 2015-10-29 12:31:21
    通常我们通过hdfs读取文档数据时,都会伴随许多空格等特殊的分割符号,此时需要提取出里面的数据时可以用到正则表达式...直接用今天遇到的实际案例来进行说明Scala中的正则表达式的使用。  在从hdfs中获取到的数据中,
  • 正则表达式,忽略大小写

    千次阅读 2018-08-28 10:57:54
    import re url = ‘abc.gif’ res = re.search('.*(.GIF$)', url, re.I)    
  • java正则表达式的忽略大小写

    万次阅读 2007-05-27 20:03:00
    java正则表达式: (?i)abc 表示abc都忽略大小写 a(?i)bc 表示bc忽略大小写 a((?i)b)c 表示只有b忽略大小写 也可以用Pattern.compile(rexp,Pattern.CASE_INSENSITIVE)表示整体都忽略大小写
  • 正则表达式 //"""原生表达 val regex="""([0-9]+)([a-z]+)""".r val numPattern="[0-9]+".r val numberPattern="""\s+[0-9]+\s+""".r模式匹配一 //findAllIn()方法返回遍历所有匹配项的迭代器 for(matchString ...
  • 去掉字符串中的中文汉字的正则表达式
  • scala 正则表达式匹配子串

    千次阅读 2016-09-16 09:04:13
    scala中的正则与其他语言中的正则的用法有些不同,大致有两种用法: 一、匹配字符串中所有符合特定格式的串,比如匹配所有整数: scala> val numpattern ="""\d+""".r numpattern: scala.util.matching.Regex = \d+ ...
  • new_str = re.sub('[^\w\u4e00-\u9fff]+', '','江苏 » 无锡市:婚礼司仪roger') 江苏无锡市婚礼司仪roger
  • scala 中文匹配正则表达式

    千次阅读 2017-02-23 10:04:12
    import scala.util.matching.Regex //匹配中文 中文 [\u4e00-\u9fa5] var p_t=new Regex("[\u4e00-\u9fa5]+:[\u4e00-\u9fa5]+")
  • scala模式匹配和正则表达式

    千次阅读 2014-06-27 15:48:29
    匹配字面量和常量
  • 假如有如下json文件:   { "Result": [ { "country": "TW", "mcc": "466", "chatUrl": "... }, { "country": &q
1 2 3 4 5 ... 20
收藏数 4,634
精华内容 1,853
关键字:

scala正则表达式