精华内容
下载资源
问答
  • java正则表达式用法示例 当我开始使用Java时,正则表达式对我来说是一场噩梦。... 正则表达式不是特定于语言的,但是每种语言正则表达式略有不同。 Java正则表达式与Perl最相似。 Java正则表达式类存在于...

    java正则表达式用法示例

    当我开始使用Java时,正则表达式对我来说是一场噩梦。 本教程旨在帮助您掌握Java正则表达式,并让我定期返回以刷新我的正则表达式学习。

    什么是正则表达式?

    正则表达式定义字符串的模式。 正则表达式可用于搜索,编辑或处理文本。 正则表达式不是特定于语言的,但是每种语言的正则表达式略有不同。 Java正则表达式与Perl最相似。

    Java正则表达式类存在于java.util.regex软件包中,该软件包包含三个类: PatternMatcherPatternSyntaxException

    1.模式对象是正则表达式的编译版本。 它没有任何公共构造函数,我们使用它的公共静态方法编译通过传递正则表达式参数来创建模式对象。

    2. Matcher是将输入的字符串模式与创建的模式对象进行匹配的正则表达式引擎对象。 此类没有任何公共构造函数,并且我们使用模式对象匹配器方法(将输入String作为参数)来获得Matcher对象。 然后,我们使用matchs方法,该方法根据输入的String是否匹配正则表达式模式返回布尔结果。

    3.如果正则表达式语法不正确,则会引发PatternSyntaxException。

    让我们通过一个简单的示例查看所有这些类的作用:

    package com.journaldev.util;
    
    import java.util.regex.*;
    
    public class PatternExample {
    
    	public static void main(String[] args) {
    		Pattern pattern = Pattern.compile('.xx.');
    		Matcher matcher = pattern.matcher('MxxY');
    		System.out.println('Input String matches regex - '+matcher.matches());
    		// bad regular expression
    		pattern = Pattern.compile('*xx*');
    
    	}
    
    }

    上面程序的输出是:

    Input String matches regex - true
    Exception in thread 'main' java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
    *xx*
    ^
    	at java.util.regex.Pattern.error(Pattern.java:1924)
    	at java.util.regex.Pattern.sequence(Pattern.java:2090)
    	at java.util.regex.Pattern.expr(Pattern.java:1964)
    	at java.util.regex.Pattern.compile(Pattern.java:1665)
    	at java.util.regex.Pattern.(Pattern.java:1337)
    	at java.util.regex.Pattern.compile(Pattern.java:1022)
    	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

    由于正则表达式围绕String展开,因此Java 1.4中对String类进行了扩展,以提供进行模式匹配的match方法。 在内部,它使用Pattern和Matcher类进行处理,但是显然,它减少了代码行。

    模式类还包含matchs方法,该方法以正则表达式和输入String作为参数,并在匹配它们后返回布尔结果。

    因此,以下代码可以很好地将输入String与正则表达式匹配。

    String str = 'bbb';
    		System.out.println('Using String matches method: '+str.matches('.bb'));
    		System.out.println('Using Pattern matches method: '+Pattern.matches('.bb', str));

    因此,如果您只需要检查输入的String是否与模式匹配,则应使用简单的String Match方法来节省时间。 仅在需要操纵输入String或需要重用模式时,才使用Pattern和Matches类。

    请注意,由正则表达式定义的模式从左到右应用于字符串,并且一旦在匹配项中使用了源字符,就无法重用它。

    例如,正则表达式“ 121”将匹配“ 31212142121”的次数是“ _121____121”的两倍。

    正则表达式常见的匹配符号

    正则表达式 描述
    匹配任何单个符号,包括所有内容 (“ ..”,“。a%”)– true(“ ..”,“。a”)– true

    (“ ..”,“ a”)–否

    ^ xxx 在行首匹配xxx正则表达式 (“ ^ ac”,“ abcd”)– true(“ ^ a”,“ a”)– true

    (“ ^ a”,“ ac”)–否

    xxx $ 在行尾匹配正则表达式xxx (“ ..cd $”,“ abcd”)–真实(“ a $”,“ a”)–真实

    (“ a $”,“ aca”)–否

    [abc] 可以匹配字母a,b或c。 []被称为字符类。 (“ ^ [abc] d。”,“ ad9”)–正确(“ [ab] .d $”,“坏”)–正确

    (“ [ab] x”,“ cx”)–否

    [abc] [12] 可以匹配a,b或c,然后匹配1或2 (“ [ab] [12]。”,“ a2#”)– true(“ [ab] .. [12]”,“ acd2”)– true

    (“ [ab] [12]”,“ c2”)–否

    [^ abc] 当^是[]中的第一个字符时,它会否定模式,匹配除a,b或c之外的任何其他字符 (“ [[^ ab] [^ 12]。”,“ c3#”)–真(“ [[^ ab] .. [^ 12]”,“ xcd3”)–真

    (“ [^ ab] [^ 12]”,“ c2”)–否

    [a-e1-8] 匹配范围从a到e或1到8 (“ [a-e1-3]”,“ d#”)–真(“ [a-e1-3]”,“ 2”)-真

    (“ [a-e1-3]”,“ f2”)–否

    xx | yy 匹配正则表达式xx或yy (“ x。| y”,“ xa”)– true(“ x。| y”,“ y”)

    (“ x。| y”,“ yz”)–否


    Java正则表达式元字符

    正则表达式 描述
    \ d 任何数字,少于[0-9]
    \ D 任何非数字,是[^ 0-9]的缩写
    \ s 任何空格字符,是[\ t \ n \ x0B \ f \ r]的缩写
    \ S 任何非空白字符,是[^ \ s]的缩写
    \ w 任何文字字符,是[a-zA-Z_0-9]的缩写
    \ W 任何非单词字符,是[^ \ w]的缩写
    \ b 单词边界
    \ B 非单词边界

    在正则表达式中有两种方法可以将元字符用作普通字符。

    1. 在元字符之前加一个反斜杠(\)。
    2. 保持元字符在\ Q(以引号开头)和\ E(以引号结尾)之内。


    正则表达式量词

    量词指定要匹配的字符的出现次数。

    正则表达式 描述
    X? x发生一次或根本不发生
    X* X出现零次或多次
    X + X发生一次或多次
    X {n} X正好发生n次
    X {n,} X出现n次或更多次
    X {n,m} X发生至少n次但不超过m次

    量词也可以与字符类和捕获组一起使用。

    例如,[abc] +表示a,b或c一次或多次。

    (abc)+表示“ abc”组再出现一次。 我们现在将讨论捕获组

    正则表达式捕获组

    捕获组用于将多个字符视为一个单元。 您可以使用()创建一个组。 输入String与捕获组匹配的部分被保存到内存中,可以使用Backreference进行调用。

    您可以使用matcher.groupCount方法找出正则表达式模式中的捕获组数。 例如在((a)(bc))中包含3个捕获组; ((a)(bc)),(a)和(bc)。

    您可以在正则表达式中使用反引号 (\),然后再调用要调用的组数。

    捕获组和反向引用可能会造成混淆,因此让我们通过一个示例来理解它。

    System.out.println(Pattern.matches('(\\w\\d)\\1', 'a2a2')); //true
    		System.out.println(Pattern.matches('(\\w\\d)\\1', 'a2b2')); //false
    		System.out.println(Pattern.matches('(AB)(B\\d)\\2\\1', 'ABB2B2AB')); //true
    		System.out.println(Pattern.matches('(AB)(B\\d)\\2\\1', 'ABB2B3AB')); //false

    在第一个示例中,在运行时,第一个捕获组是(\ w \ d),当与输入字符串“ a2a2”匹配并保存在内存中时,其计算结果为“ a2”。 因此\ 1指的是“ a2”,因此它返回true。 由于相同的原因,第二条语句打印为false。
    尝试自己了解语句3和4的这种情况。

    现在,我们将研究一些重要的Pattern和Matcher类方法。

    我们可以创建带有标志的Pattern对象。 例如模式。 CASE_INSENSITIVE启用不区分大小写的匹配。

    模式类还提供了类似于String类split()方法的split(String)
    模式类toString()方法返回从中编译此模式的正则表达式String。

    Matcher类具有start()end()索引方法,可精确显示在输入字符串中找到匹配项的位置。

    Matcher类还提供String操作方法replaceAll(String替换)replaceFirst(String替换)

    现在,我们将通过一个简单的java类看到这些常用功能:

    package com.journaldev.util;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class RegexExamples {
    
    	public static void main(String[] args) {
    		// using pattern with flags
    		Pattern pattern = Pattern.compile('ab', Pattern.CASE_INSENSITIVE);
    		Matcher matcher = pattern.matcher('ABcabdAb');
    		// using Matcher find(), group(), start() and end() methods
    		while (matcher.find()) {
    			System.out.println('Found the text \'' + matcher.group()
    					+ '\' starting at ' + matcher.start()
    					+ ' index and ending at index ' + matcher.end());
    		}
    
    		// using Pattern split() method
    		pattern = Pattern.compile('\\W');
    		String[] words = pattern.split('one@two#three:four$five');
    		for (String s : words) {
    			System.out.println('Split using Pattern.split(): ' + s);
    		}
    
    		// using Matcher.replaceFirst() and replaceAll() methods
    		pattern = Pattern.compile('1*2');
    		matcher = pattern.matcher('11234512678');
    		System.out.println('Using replaceAll: ' + matcher.replaceAll('_'));
    		System.out.println('Using replaceFirst: ' + matcher.replaceFirst('_'));
    	}
    
    }

    上面程序的输出是:

    Found the text 'AB' starting at 0 index and ending at index 2
    Found the text 'ab' starting at 3 index and ending at index 5
    Found the text 'Ab' starting at 6 index and ending at index 8
    Split using Pattern.split(): one
    Split using Pattern.split(): two
    Split using Pattern.split(): three
    Split using Pattern.split(): four
    Split using Pattern.split(): five
    Using replaceAll: _345_678
    Using replaceFirst: _34512678

    正则表达式是Java面试问题的领域之一,在接下来的几篇文章中,我将提供一些实际示例。

    参考: 开发人员食谱博客上的JCG合作伙伴 Pankaj Kumar的Java正则表达式示例教程

    翻译自: https://www.javacodegeeks.com/2012/11/java-regular-expression-tutorial-with-examples.html

    java正则表达式用法示例

    展开全文
  • 1.2 正则表达式的特点1.3 正则表达式的语法1.3.1 简单的语法使用1.3.2 语法规范普通字符非打印字符特殊字符限定符二、正则表达式的修饰符三、正则表达式的多种修饰类3.1 字符类3.2 元字符3.3 匹配正则后的默认字符串...

    一、了解正则表达式

    1.1 什么是正则表达式?

    正则表达式,又称规则表达式。正则表达式是对字符 串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。通常被用来检索、替换那些符合某个模式(规则)的文本。在Java Web中用于前端校验的字符串限制。

    1.2 正则表达式的特点

    • 灵活性、逻辑性和功能性非常强
    • 可以迅速地用极简单的方式达到字符串的复杂控制
    • 对于刚接触的人来说,比较晦涩难懂

    1.3 正则表达式的语法

    1.3.1 简单的语法使用

    复杂版:var patt=new RegExp(pattern,modifiers);

    简单版:var patt=/pattern/modifiers;

    1.3.2 语法规范

    正则表达式(regular expression)描述了一种字符串匹配的模式(pattern),可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

    普通字符

    普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。

    非打印字符

    非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列

    非打印字符描述
    \cx匹配由x指明的控制字符。例如, \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则,将 c 视为一个原义的 ‘c’ 字符。
    \f匹配一个换页符。等价于 \x0c 和 \cL。
    \n匹配一个换行符。等价于 \x0a 和 \cJ。
    \r匹配一个回车符。等价于 \x0d 和 \cM。
    \s匹配任何空白字符,包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。
    \S匹配任何非空白字符。等价于[^ \f\n\r\t\v]
    \t匹配一个制表符。等价于 \x09 和 \cI。
    \v匹配一个垂直制表符。等价于 \x0b 和 \cK。
    特殊字符

    所谓特殊字符,就是一些有特殊含义的字符,如上面说的 runoo*b 中的 *****,简单的说就是表示任何字符串的意思。如果要查找字符串中的 ***** 符号,则需要对 ***** 进行转义,即在其前加一个 \: runo*ob 匹配 runo*ob。

    许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符,必须首先使字符"转义",即,将反斜杠字符 \ 放在它们前面。下表列出了正则表达式中的特殊字符

    特别字符描述
    $匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性,则 $ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身,请使用 $。
    ( )标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符,请使用 ( 和 )。
    *匹配前面的子表达式零次或多次。要匹配 * 字符,请使用 *。
    +匹配前面的子表达式一次或多次。要匹配 + 字符,请使用 +。
    .匹配除换行符 \n 之外的任何单字符。要匹配 . ,请使用 . 。
    [标记一个中括号表达式的开始。要匹配 [,请使用 [。
    ?匹配前面的子表达式零次或一次,或指明一个非贪婪限定符。要匹配 ? 字符,请使用 ?。
    \将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如, ‘n’ 匹配字符 ‘n’。’\n’ 匹配换行符。序列 ‘\’ 匹配 “”,而 ‘(’ 则匹配 “(”。
    ^匹配输入字符串的开始位置,除非在方括号表达式中使用,当该符号在方括号表达式中使用时,表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身,请使用 ^。
    {标记限定符表达式的开始。要匹配 {,请使用 {。
    |指明两项之间的一个选择。要匹配 | ,请使用 \
    限定符

    限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 ***** 或 +?{n}{n,}{n,m} 共6种。正则表达式的限定符有:

    字符描述
    *匹配前面的子表达式零次或多次。例如,zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。
    +匹配前面的子表达式一次或多次。例如,‘zo+’ 能匹配 “zo” 以及 “zoo”,但不能匹配 “z”。+ 等价于 {1,}。
    ?匹配前面的子表达式零次或一次。例如,“do(es)?” 可以匹配 “do” 、 “does” 中的 “does” 、 “doxy” 中的 “do” 。? 等价于 {0,1}。
    {n}n 是一个非负整数。匹配确定的 n 次。例如,‘o{2}’ 不能匹配 “Bob” 中的 ‘o’,但是能匹配 “food” 中的两个 o。
    {n,}n 是一个非负整数。至少匹配n 次。例如,‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’,但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。
    {n,m}m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。例如,“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。

    二、正则表达式的修饰符

    修饰符用于执行区分大小写和全局匹配

    修饰符描述
    i执行对大小写不敏感的匹配。
    g执行全局匹配(查找所有匹配而非在找到第一个匹配后停止)。
    m执行多行匹配。
      // 默认会区分大小写
      var reg = /hello/
      var flag = reg.test("Hello World")
      console.log(flag) // false
      // 添加i修饰符 不区分大小写
      var reg2 = /hello/i
      var flag2 = reg2.test("Hello World")
      console.log(flag2) // true
     
      var str = "I'm in a bad mood,really bad"
      // 默认非全局匹配
      var reg3 = /bad/
      var newStr = str.replace(reg3,"good")
      // 只替换了一个bad
      console.log(newStr) // I'm in a good mood,really bad
      // 全局匹配
      var reg4 = /bad/g
      var newStr2 = str.replace(reg4,"good")
      // 替换了全局的bad为good
      console.log(newStr2) // I'm in a good mood,really good
     
      // 同时使用
      var reg5 = /bad/gi
      var newStr3 = reg5.test("i am a BaD");
      console.log(newStr3);
    

    三、正则表达式的多种修饰类

    • 以下带有[]{}的都是正则表达式,[]内代表是对字符串的限制,而{}是代表长度。如果没有书写{}则默认长度为1

    • matches方法为正则表达式匹配方法,判断字符串是否满足正则表达式的校验(后面也会讲到)

    3.1 字符类

    字符类用于查找某个范围内的字符

    表达式描述
    [abc]查找方括号之间的任何字符。
    [^abc]查找任何不在方括号之间的字符。
    [0-9]查找任何从 0 至 9 的数字。
    [a-z]查找任何从小写 a 到小写 z 的字符。
    [A-Z]查找任何从大写 A 到大写 Z 的字符。
    [A-z]查找任何从大写 A 到小写 z 的字符。
    [abcd]查找给定集合内的任何字符。
    [^abcd]查找给定集合外的任何字符。
    (red|blue|green)查找任何指定的选项。
    //      [abc] a、b 或 c(简单类)
            String reg1 = "[abc]";
            System.out.println("a".matches(reg1));    // true
    
    //      [^abc] 任何字符,除了 a、b 或 c(否定)
            String reg2 = "[^abc]";
            System.out.println("d".matches(reg2));    // true
    
    //      [a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内(范围)
            String reg3 = "[a-zA-Z]";
            System.out.println("ab".matches(reg3));    // false
    
    //      [0-9] 0到9的字符都包括
            String reg4 = "[0-9]";
            System.out.println("0".matches(reg4));    // true
    
    //      需求:有一个字符,可以是a-z,也可以是A-Z,也可以是0-9,也可以是?
            String reg5 = "[a-zA-Z0-9?]";
            System.out.println("!".matches(reg5));    // false
    

    3.2 元字符

    元字符(Metacharacter)是拥有特殊含义的字符(注意:在使用的时候需要\\W,因为一个\默认为转义字符)

    元字符描述
    .查找单个字符,除了换行和行结束符。
    \w查找单词字符。
    \W查找非单词字符。
    \d查找数字。
    \D查找非数字字符。
    \s查找空白字符。
    \S查找非空白字符。
    //      . 任何字符。
            String reg1 = ".";
            System.out.println(">".matches(reg1));     // true
            System.out.println(">a".matches(reg1));    // false
    
    //      \d 数字:[0-9]
            String reg2 = "\\d";
            System.out.println("11".matches(reg2));    // false
    
    //      \D 非数字:[^0-9]
            String reg3 = "[^0-9]";
            System.out.println("a".matches(reg3));     // true
            System.out.println("11".matches(reg3));    // false
    
            String reg4 = "\\D";
            System.out.println("1".matches(reg4));    // false
    
    //      \w 单词字符:[a-zA-Z_0-9]
            String reg5 = "\\w";
            System.out.println("_".matches(reg5));    // true
    
            String reg6 = "[a-zA-Z0-9_]";
            System.out.println("_".matches(reg6));    // true
    
    //      \W 非单词字符:[^\w]
            String reg7 = "[^a-zA-Z0-9_]";
            System.out.println("a".matches(reg7));    // false
    
            String reg8 = "[^\\w]";
            System.out.println("!".matches(reg8));    // true
    
            String reg9 = "[\\W]";
            System.out.println("!".matches(reg9));    // true
    
    //      \s 空白字符:[ \t\n\x0B\f\r]
            String reg10 = "\\s";
            System.out.println(" ".matches(reg10));    // true
    
    //      \S 非空白字符:[^\s]
            String reg11 = "\\S";
            System.out.println("!".matches(reg11));    // true
    

    3.3 匹配正则后的默认字符串

    在使用以下四种正则表达式matches方法匹配字符串时,以下四种正则表达式表示的意义均是相同的!

    1. String reg1 = “abc”;
      • 当reg1在使用matches进行对字符串的正则校验时,它已经不是一个普通的字符串了,"abc"隐式的存在[]和{},也就是等价于我们的第三种,为每一个字符添加了一个[]和{}
    2. String reg2 = [a][b][c];
      • reg2正则表达式隐式存在{1}的长度,所以也是等于于我们的第三种
    3. String reg3 = [a]{1}[b]{1}[c]{1};
      • reg3正则表达式是没有省略任何内容的正则表达式
    4. String reg4 = [abc]{3}
      • reg4正则表达式可以解释为:在abc三个字符中,必须满足它的3个长度,也就是正则校验时规定字符串必须是abc

    注意: 第一种看起来是一个字符串,当调用了matches方法进行字符串的正则校验时,该字符串摇身一变就成为了一个特殊的正则表达式!

    3.4 数量词

    量词描述
    n+匹配任何包含至少一个 n 的字符串。例如,/a+/ 匹配 “candy” 中的 “a”,“caaaaaaandy” 中所有的 “a”。
    n*匹配任何包含零个或多个 n 的字符串。例如,/bo*/ 匹配 “A ghost booooed” 中的 “boooo”,“A bird warbled” 中的 “b”,但是不匹配 “A goat grunted”。
    n?匹配任何包含零个或一个 n 的字符串。例如,/e?le?/ 匹配 “angel” 中的 “el”,“angle” 中的 “le”。
    n{X}匹配包含 X 个 n 的序列的字符串。例如,/a{2}/ 不匹配 “candy,” 中的 “a”,但是匹配 “caandy,” 中的两个 “a”,且匹配 “caaandy.” 中的前两个 “a”。
    n{X,}X 是一个正整数。前面的模式 n 连续出现至少 X 次时匹配。例如,/a{2,}/ 不匹配 “candy” 中的 “a”,但是匹配 “caandy” 和 “caaaaaaandy.” 中所有的 “a”。
    n{X,Y}X 和 Y 为正整数。前面的模式 n 连续出现至少 X 次,至多 Y 次时匹配。例如,/a{1,3}/ 不匹配 “cndy”,匹配 “candy,” 中的 “a”,“caandy,” 中的两个 “a”,匹配 “caaaaaaandy” 中的前面三个 “a”。注意,当匹配 “caaaaaaandy” 时,即使原始字符串拥有更多的 “a”,匹配项也是 “aaa”。
    n$匹配任何结尾为 n 的字符串。
    ^n匹配任何开头为 n 的字符串。
    ?=n匹配任何其后紧接指定字符串 n 的字符串。
    ?!n匹配任何其后没有紧接指定字符串 n 的字符串。
    //      X? :X,一次或一次也没有
            String reg1 = "[a]?";    // 要么是“a”要么什么都没有
            System.out.println("aaa".matches(reg1));    // false
    
    //      X* :X,零次到多次
            String reg2 = "[a]*";
            System.out.println("b".matches(reg2));    // false
    
    //      X+ :X,一次到 多次
            String reg3 = "[a]+";
            System.out.println("".matches(reg3));    // false
    
    //      X{n} :X,恰好 n 次
            String reg4 = "[ab]{3}";    // 内容由a或b组成,长度为3
            System.out.println("aaa".matches(reg4));    // true
    
    //      X{n,} :X,至少 n 次
            // 0次到多次
            String reg5 = "[abc]{0,}";    // 内容由a组成,0次到多次!
            System.out.println("aaaa".matches(reg5));    // true
    
    //      1次到多次
            String reg6 = "[a]{1,}";
            System.out.println("".matches(reg6));    // false
    
    //      X{n,m} :X,至少 n 次,但是不超过 m 次
            String reg7 = "[abc]{2,3}";
            System.out.println("abca".matches(reg7));    // false
            System.out.println("abc".matches(reg7));     // true
    

    3.5 正则表达式的字符串方法

    方法描述
    search检索与正则表达式相匹配的值。
    match找到一个或多个正则表达式的匹配。
    replace替换与正则表达式匹配的子串。
    split把字符串分割为字符串数组。

    字符串分割示例(如下分割每一个打印内容都是都是相同的即为a b c d)

    //      "a,b,c,d"
            String   str1  = "a,b,c,d";
            String   reg1  = "[,]{1}";
            String[] strs1 = str1.split(reg1);
    
            for (String str : strs1) {
                System.out.println(str);
            }
    
            System.out.println("-----------");
    
    //      "a,,b,,c,,d"
            String str2 = "a,,b,,c,,d";
    
    //      String reg2 = ",,";
            String   reg2  = "[,]{2}";
            String[] strs2 = str2.split(reg2);
    
            for (String str : strs2) {
                System.out.println(str);
            }
    
            System.out.println("-----------");
    
    //      "a,b,,c,,,d"
            String   str3  = "a,b,,c,,,d";
            String   reg3  = "[,]{1,3}";
            String[] strs3 = str3.split(reg3);
    
            for (String str : strs3) {
                System.out.println(str);
            }
    
            System.out.println("-----------");
    
    //      "a,,,,,,,,,b,,,,,,,,,c,,,,,d"
            String   str4  = "a,,,,,,,,,b,,,,,,,,,c,d";
            String   reg4  = "[,]+";
            String[] strs4 = str4.split(reg4);
    
            for (String str : strs4) {
                System.out.println(str);
            }
    

    Java Script示例

    <script>
      var str = "hi66morning77"
      // 匹配连续的2个数字 非全局匹配
      var reg = /\d{2}/
      console.log(str.match(reg)[0]) // 66
      // 匹配连续的2个数字 全局匹配(推荐)
      var reg2 = /\d{2}/g
      console.log(str.match(reg2)) // ["66", "77"]  
    
    var str = "hi66morning77"
      // 匹配连续的2个数字 非全局匹配
      var reg = /\d{2}/
      console.log(str.search(reg)) // 2
      // 匹配a,b,m中的一个
      var reg2 = /[abm]/
      console.log(str.search(reg2))  // 4 
    </script>
    

    3.6 正则表达式的对象

    ( Pattern和Matcher)模式和匹配器的典型调用顺序如下:

    		//正则表达式
            String reg = "[a]{3}";
            //正则表达式 转换为 正则对象
            Pattern pattern = Pattern.compile(reg);
            //匹配字符串,匹配对象
            Matcher matcher = pattern.matcher("aaa");
            //开始匹配
            boolean flag = matcher.matches();
            System.out.println(flag);
    

    3.7 正则表达式校验手机号

    • 需求:把一个字符串中的手机号码获取出来

    • 要求:

      • 手机号码共11位
      • 开头第一位必须是1
      • 第二位必须是356789的其中一位
      • 其他9为均为数字(数字的范围即是0~9)
    		/**
             * 手机号码
             * 手机号码共11位
             * 开头第一位必须是1
             * 第二位必须是356789的其中一位
             * 其他9为均为数字(数字的范围即是0~9)
             */
            String str = "18627775385...fadsfds18627775383..dsfjdsa18627775384";
            String reg = "[1]{1}[356789]{1}\\d{9}";
            //获取正则对象
            Pattern pattern = Pattern.compile(reg);
            //获取匹配对象
            Matcher matcher = pattern.matcher(str);
            //开始查找手机号
            //find:在str中找子字符串,子字符串要和正则匹配
            List<String> phones = new ArrayList<>();
            while (matcher.find()) {
                //找到了手机号,获取手机号
                String phone = matcher.group();
                phones.add(phone);
            }
    
            /**
             * 遍历打印获取到的手机号码
             */
            for (String phone : phones) {
                System.out.println(phone);
            }
    

    3.8 正则表达式的RegExp对象方法

    方法描述
    exec检索字符串中指定的值。返回找到的值,并确定其位置。没有发现匹配,则返回 null。
    test检索字符串中指定的值。返回 true 或 false。
    var patt1 = new RegExp("e");
    document.write(patt1.test("The best things in life are free"));
    //由于该字符串中存在字母 "e",以上代码的输出将是:true
    
    var patt1 = new RegExp("e");
    document.write(patt1.exec("The best things in life are free"));
    //由于该字符串中存在字母 "e",以上代码的输出将是:e
    

    四、正则表达式的使用

    4.1 正则表达式的简单使用

    User实体类+校验
    package com.mylifes1110.java.userdemo;
    
    /**
     * User实体类+校验
     *
     * 创建一个User对象,有账号、密码、邮箱
     * 账号:数字和字母组成;第一位必须是大写字母;长度范围6~10
     * 密码:由数字、字母和_组成;第一位必须是字母;长度为6
     * 邮箱:由qq号码、@和.组成;必须是qq邮箱
     */
    public class User {
        private String username;
        private String password;
        private String email;
    
        public User() {}
    
        public User(String username, String password, String email) {
            if (validateUsername(username)) {
                this.username = username;
            } else {
                throw new MyIllegalArgumentsException("账号输入错误!");
            }
    
            if (validatePassword(password)) {
                this.password = password;
            } else {
                throw new MyIllegalArgumentsException("密码输入错误!");
            }
    
            if (validateEmail(email)) {
                this.email = email;
            } else {
                throw new MyIllegalArgumentsException("邮箱输入错误!");
            }
        }
    
        @Override
        public String toString() {
            return "User{" + "username='" + username + '\'' + ", password='" + password + '\'' + ", email='" + email + '\''
                   + '}';
        }
    
        /**
         * 校验邮箱
         * 邮箱:由qq号码、@和.组成;必须是qq邮箱(QQ号码位数是由5位到11位并且没有0开头的QQ号码)
         */
        private boolean validateEmail(String email) {
            String  reg     = "[1-9]{5,11}@qq\\.com";
            boolean matches = email.matches(reg);
    
            return matches;
        }
    
        /**
         * 校验密码
         * 密码:由数字、字母和_组成;第一位必须是字母;长度为6
         */
        private boolean validatePassword(String password) {
            String  reg     = "[a-zA-Z]\\w{5}";
            boolean matches = password.matches(reg);
    
            return matches;
        }
    
        /**
         * 校验账号
         * 账号:数字和字母组成;第一位必须是大写字母;长度范围6~10
         */
        private boolean validateUsername(String username) {
            String  reg     = "[A-Z][a-zA-Z0-9]{5,9}";
            boolean matches = username.matches(reg);
    
            return matches;
        }
    
        public String getEmail() {
            return email;
        }
    
        public void setEmail(String email) {
            if (validateEmail(email)) {
                this.email = email;
            } else {
                throw new MyIllegalArgumentsException("邮箱输入错误!");
            }
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            if (validatePassword(password)) {
                this.password = password;
            } else {
                throw new MyIllegalArgumentsException("密码输入错误!");
            }
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            if (validateUsername(username)) {
                this.username = username;
            } else {
                throw new MyIllegalArgumentsException("账号输入错误!");
            }
        }
    }
    
    测试类
    package com.mylifes1110.java.userdemo;
    
    import java.util.Scanner;
    
    /**
     * 创建一个User对象,有账号、密码、邮箱
     * 账号:数字和字母组成;第一位必须是大写字母;长度范围6~10
     * 密码:由数字、字母和_组成;第一位必须是字母;长度为6
     * 邮箱:由qq号码、@和.组成;必须是qq邮箱
     */
    public class UserTest {
        public static void main(String[] args) {
            Scanner sc   = new Scanner(System.in);
            User    user = new User();
    
            System.out.print("请输入账号:");
    
            String username = sc.nextLine();
    
            System.out.print("请输入密码:");
    
            String password = sc.nextLine();
    
            System.out.print("请输入邮箱:");
    
            String email = sc.nextLine();
    
            user.setUsername(username);
            user.setPassword(password);
            user.setEmail(email);
            System.out.println(user);
        }
    }
    
    自定义异常类
    package com.mylifes1110.java.userdemo;
    
    public class MyIllegalArgumentsException extends RuntimeException {
        public MyIllegalArgumentsException() {
        }
    
        public MyIllegalArgumentsException(String message) {
            super(message);
        }
    
        public MyIllegalArgumentsException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public MyIllegalArgumentsException(Throwable cause) {
            super(cause);
        }
    
        public MyIllegalArgumentsException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
            super(message, cause, enableSuppression, writableStackTrace);
        }
    }
    

    4.2 JavaScript中正则表达式常用校验

    匹配手机号
    var reg = /^1\d{10}$/;
    
    匹配QQvar reg = /^[1-9]\d{4,10}$/;
    
    匹配身份证号
    var reg = /^[1-9]\d{16}[Xx\d]$/;
    
    变量名检测(只能由字母,数字,下划线组成,且不能以数字开头,长度6-15)
    var reg = /^[A-z_]\w{5,14}$/;
    
    判断是否为邮箱email
    验证规则: 电子邮箱的正确写法一般为: 用户名@邮箱网站.com(.cn) 
    
    第一部分:由字母、数字、下划线、短线“-”组成
    
    第二部分:为一个域名,域名由字母、数字、短线“-”、域名后缀组成(域名后缀一般为两位到三位。例如:com cn net现在域名有的也会大于四位)
    
     function isEmail(str){
            var reg =/^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\.[a-zA-Z0-9_-]{2,3}){1,2})$/;
            return reg.test(str);
    }
    
    展开全文
  • 简单正则表达式We live in a data-centric age. Data has been described as the new oil. But just like oil, data isn’t always useful in its raw form. One form of data that is particularly hard to use in ...

    简单正则表达式

    We live in a data-centric age. Data has been described as the new oil. But just like oil, data isn’t always useful in its raw form. One form of data that is particularly hard to use in its raw form is unstructured data.

    我们生活在以数据为中心的时代。 数据被描述为新油 。 但是,就像石油一样,数据并非总是以原始形式有用。 非结构化数据是一种特别难以以原始形式使用的数据形式。

    A lot of data is unstructured data. Unstructured data doesn’t fit nicely into a format for analysis, like an Excel spreadsheet or a data frame. Text data is a common type of unstructured data and this makes it difficult to work with. Enter regular expressions, or regex for short. They may look a little intimidating at first, but once you get started, using them will be a picnic!

    许多数据是非结构化数据。 非结构化数据不太适合用于分析格式,例如Excel电子表格或数据框 。 文本数据是非结构化数据的一种常见类型,这使其难以使用。 输入正则表达式 ,或正则表达式的简称。 一开始它们可能看起来有些吓人,但是一旦您开始使用它们,那将是一次野餐!

    More comfortable with python? Try my tutorial for using regex with python instead:

    使用python更舒服吗? 试试我的教程,将regex与python结合使用:

    stringr(The stringr Library)

    We’ll use the stringr library. The stringr library is built off a C library, so all of its functions are very fast.

    我们将使用stringr库。 stringr库是基于C库构建的,因此其所有功能都非常快。

    To install and load the stringr library in R, use the following commands:

    要在R中安装和加载stringr库,请使用以下命令:

    See how easy that is? To make things even easier, most function names in the stringr package start with str. Let’s take a look at a couple of the functions we have available to us in this module:

    看到那有多么容易? 为了使事情变得更加简单, stringr包中的大多数函数名称都以str开头。 让我们看一下本模块中提供给我们的几个功能:

    1. str_extract_all(string, pattern): This function returns a list with a vector containing all instances of pattern in string

      str_extract_all(string, pattern) :此函数返回一个带有向量的列表,该向量包含string中所有pattern实例

    2. str_replace_all(string, pattern, replacement): This function returns string with instances of pattern in string replaced with replacement

      str_replace_all(string, pattern, replacement) :该函数返回string与实例patternstring替换为replacement

    You may have already used these functions. They have pretty straightforward applications without adding regex. Think back to the times before social distancing and imagine a nice picnic in the park, like the image above. Here’s an example string with what everyone is bringing to the picnic. We can use it to demonstrate the basic usage of the regex functions:

    您可能已经使用了这些功能。 他们有非常简单的应用程序,而无需添加正则表达式。 回想一下与社会隔离之前的时代,想象一下在公园里野餐的乐趣,就像上面的图片一样。 这是每个人带去野餐的字符串示例。 我们可以用它来演示正则表达式功能的基本用法:

    basicString <- "Drew has 3 watermelons, Alex has 4 hamburgers, Karina has 12 tamales, and Anna has 6 soft pretzels"

    If I want to pull every instance of one person’s name from this string, I would simply pass the name and basic_string to str_extract_all():

    如果我想从该字符串中提取一个人的名字的每个实例,我只需将名字和basic_string传递给str_extract_all()

    The result will be a list with all occurrences of the pattern. Using this example, basicExtractAll will have the following list with 1 vector as output:

    结果将是包含所有出现的模式的列表。 使用此示例, basicExtractAll将具有以下列表,其中1个向量作为输出:

    [[1]]
    [1] "Drew"

    Now let’s imagine that Alex left his 4 hamburgers unattended at the picnic and they were stolen by Shawn. str_replace_all can replace any instances of Alex with Shawn:

    现在,让我们想象一下亚历克斯在野餐时无人看管的情况下留下了他的4个汉堡,它们被肖恩偷走了。 str_replace_all可以用Shawn替换Alex的任何实例:

    The resulting string will show that Shawn now has 4 hamburgers. What a lucky guy 🍔.

    结果字符串将显示Shawn现在有4个汉堡包。 真幸运。

    "Drew has 3 watermelons, Shawn has 4 hamburgers, Karina has 12 tamales, and Anna has 6 soft pretzels"

    The examples so far are pretty basic. There is a time and place for them, but what if we want to know how many total food items there are at the picnic? Who are all the people with items? What if we need this data in a data frame for further analysis? This is where you will start to see the benefits of regex.

    到目前为止,这些示例都是非常基本的。 他们有时间和地点,但是如果我们想知道野餐中总共有多少食物,该怎么办? 谁都是物品的人? 如果我们需要数据框中的数据进行进一步分析怎么办? 在这里,您将开始看到正则表达式的好处。

    正则表达式 (Regex Vocab)

    There are several concepts that drive regex:

    有几种驱动正则表达式的概念:

    1. Character sets

      字符集
    2. Meta characters

      元字符
    3. Quantifiers

      量词
    4. Capture Groups

      捕获组

    This is not an exhaustive list, but is plenty to help us hit the ground running.

    这不是一个详尽的清单,但足以帮助我们起步。

    字符集 (Character Sets)

    Character sets represent options inside of brackets, with regex matching only one of the options. There are multiple things we can do with character sets:

    字符集表示方括号内的选项,而正则表达式仅匹配选项之一。 我们可以使用字符集进行多种操作:

    • Match a group of characters: We can find all of the vowels in our string by putting every vowel in brackets, for example,[aeiou]

      匹配一组字符 :通过将每个元音放在方括号中,我们可以找到字符串中的所有元音,例如[aeiou]

    [[1]]
    [1] "e" "a" "a" "e" "e" "o" "e" "a" "a" "u" "e" "a" "i" "a"
    [15] "a" "a" "a" "e" "a" "a" "a" "o" "e" "e"
    • Match a range of characters: We can find any capital letter from “A” to “F,” by using a hyphen, [A-F]. Character sets are case sensitive, so [A-F] is not the same as [a-f]

      匹配一系列字符 :我们可以使用连字符 [AF]来找到从“ A”到“ F”的任何大写字母 。 字符集区分大小写 ,因此[AF][af]

    [[1]]
    [1] "D" "A" "K" "A"
    • Match a range of numbers: We can find numbers between a range by adding numbers to our character set, [0-9] to find any number. Notice that the numbers are extracted as strings, not converted to numbers

      匹配数字范围 :我们可以通过将数字添加到字符集[0-9]来查找任意数字,从而找到一个范围内的数字。 请注意,数字被提取为字符串,而不是转换为数字

    [[1]]
    [1] "3" "4" "1" "2" "6"

    Character sets can contain everything from this section simultaneously, so something like [A-Ct-z7-9] is still valid. It will match every character from capital “A” to capital “C,” lowercase “t” to lowercase “z,” and 7 through 9.

    字符集可以同时包含此部分中的所有内容,因此[A-Ct-z7-9]内容仍然有效。 它将匹配从大写字母“ A”到大写字母“ C”,小写字母“ t”到小写字母“ z”以及7到9的每个字符。

    So far we can’t answer any of the questions posed earlier with just bracket groups. Let’s add some more weapons to our regex arsenal.

    到目前为止,仅使用括号组就无法回答前面提出的任何问题。 让我们在正则表达式武器库中添加更多武器。

    元字符 (Meta Characters)

    Meta characters represent a type of character. They will typically begin with a backslash \. Since the backslash \ is a special character in R, it needs to be escaped each time it is used with another backslash. In other words, R requires 2 backslashes when using meta characters. Each meta character will match to a single character. Here are some of the most important ones in action:

    元字符代表一种字符。 它们通常以反斜杠\开头。 由于反斜杠\是R中的特殊字符,因此每次与另一个反斜杠一起使用时,都必须对其进行转义。 换句话说, 使用元字符时R需要2个反斜杠 。 每个元字符将匹配一个字符。 以下是一些最重要的操作:

    • \\s: This meta character represents spaces. This will match to each space, tab, and newline character. You may also specify \\t and \\n for tab and newline characters respectively. Side note: our example string does not have any tabs, but be cautious when looking for them. Many integrated development environments, or IDE’s, have a setting that will replace all tabs with spaces while you are typing. In the example string, \\s returns a list of a vector of 17 spaces, the exact number of spaces in our example string!

      \\s :此meta字符表示空格 。 这将与每个空格,制表符和换行符匹配。 您也可以分别为制表符和换行符指定\\t\\n 。 旁注:我们的示例字符串没有任何选项卡,但是在寻找它们时请务必小心。 许多集成开发环境或IDE的设置都将在您键入时将所有选项卡替换为空格。 在示例字符串中, \\s返回一个由17个空格组成的向量的列表,这是示例字符串中空格的确切数目!

    [[1]]
    [1] " " " " " " " " " " " " " " " " " " " " " " " " " " " "
    [15] " " " " " "
    • \\w: This meta character represents alphanumeric characters. This includes all the letters a-z, capital and lowercase, and the numbers 0–9. This would be the equivalent of the bracket group [A-Za-z0-9], just much quicker to write. Take caution in remembering that the \\w meta character on its own only captures a single character, not entire words or numbers. You’ll see that in the example. Don’t worry, we’ll handle that in the next section.

      \\w :此元字符表示字母数字字符 。 其中包括所有字母az,大写和小写字母以及数字0–9。 这相当于括号组[A-Za-z0-9] ,只是编写起来要快得多。 请注意, \\w元字符本身仅捕获单个字符,而不捕获整个单词或数字,因此请务必小心。 您将在示例中看到。 不用担心,我们将在下一部分中处理。

    [[1]]
    [1] "D" "r" "e" "w" "h" "a" "s" "3" "w" "a" "t" "e" "r" "m"
    [15] "e" "l" "o" "n" "s" "A" "l" "e" "x" "h" "a" "s" "4" "h"
    [29] "a" "m" "b" "u" "r" "g" "e" "r" "s" "K" "a" "r" "i" "n"
    [43] "a" "h" "a" "s" "1" "2" "t" "a" "m" "a" "l" "e" "s" "a"
    [57] "n" "d" "A" "n" "n" "a" "h" "a" "s" "6" "s" "o" "f" "t"
    [71] "p" "r" "e" "t" "z" "e" "l" "s"
    • \\d: This meta character represents numeric digits. Using our picnic example, see how it only finds the digits in the string. You’ll notice that like bracket groups, it picks up 5 numbers instead of the 4 we expect. This is because it is looking for each individual digit, not groups of digits. We’ll see how to fix that with quantifiers next.

      \\d :此元字符表示数字 。 以我们的野餐示例为例,了解它如何仅找到字符串中的数字。 您会注意到,像括号组一样,它会选择5个数字,而不是我们期望的4个数字。 这是因为它正在查找每个单独的数字,而不是数字组。 接下来,我们将介绍如何使用量词解决此问题。

    [[1]]
    [1] "3" "4" "1" "2" "6"

    量词 (Quantifiers)

    As we saw in the previous section, a single meta character can have somewhat limited functionality. When it comes to words or numbers, we usually want to find more than 1 character at a time. This is where quantifiers come in. They allow you to quantify how many of a character you are expecting. They always come after the character they are quantifying and come in a few flavors:

    正如我们在上一节中看到的,单个元字符的功能可能有所限制。 当涉及单词或数字时, 我们通常希望一次查找多个字符 。 这是量词出现的地方。它们使您可以量化期望的字符数。 他们总是他们被量化和进来几个口味的字符来

    • + quantifies 1 or more matches. Let’s look at a new example to develop some intuition about what each quantifier will return: quantExample

      +量化1个或多个匹配项。 让我们看一个新的示例,以直观地了解每个量词将返回的内容: quantExample

    When we use the + quantifier on quantExample, it will return 4 matches. This is a good point to mention that regex looks for non-overlapping matches. In this case, it looks at each B and the character that follows it. Since we used the + quantifier, it continues to match until it reaches the end of a group of B’s.

    当我们在quantExample上使用+量词时,它将返回4个匹配项。 提到regex寻找不重叠的匹配是一个很好的观点。 在这种情况下,它将查看每个B及其后面的字符。 由于我们使用了+量词,因此它将继续匹配,直到到达一组B的末尾。

    [[1]]
    [1] "B" "BB" "BBB" "BBBB"
    • {} quantifies a specific number or range of matches. When written like {2} it will match exactly 2 of the preceding character. We’ll see some interesting results. It picked up 4 matches. This is because it is looking for each non-overlapping group of 2 B’s. There is a match in the 1st group, only 1 non-overlapping match in the 2nd group, and 2 non-overlapping matches in the 4th.

      {}量化匹配的特定数量或范围 。 当像{2}一样书写时,它将恰好匹配前一个字符中的2个。 我们将看到一些有趣的结果。 它赢得了4场比赛。 这是因为它正在寻找2个B的每个不重叠组。 第一组中有一场比赛,第二组中只有1次非重叠比赛,第四组中只有2次非重叠比赛。

    [[1]]
    [1] "BB" "BB" "BB" "BB"

    When written like {2,4}, it will match any number of B’s from 2 to 4 occurrences. Note that putting a space in your regex will NOT work. It will return an empty list.

    当像{2,4}这样写时,它将匹配2到4次出现的任意数量的B。 请注意,在正则表达式中放置空格将不起作用。 它将返回一个空列表。

    [[1]]
    [1] "BB" "BBB" "BBBB"

    We can also write this quantifier and omit the upper bound like {2,}. This will match 2 or more instances. For quantExample, it will return the exact same result as {2,4}.

    我们还可以编写此量词,并省略上限,例如{2,} 。 这将匹配2个或更多实例。 对于quantExample ,它将返回与{2,4}完全相同的结果。

    • * quantifies zero or more matches. This can be helpful when we are looking for something that may or may not be in our string.

      *量化零个或多个匹配。 当我们寻找字符串中可能存在或不存在的东西时,这可能会有所帮助。

    The * quantifier returns some strange matches when used by itself, so we can omit an example with quantExample. We will see in a following example how it can be applied when someone at our picnic is bringing a food item with a multiple word name. Without it, we wouldn’t correctly capture that Anna is bringing soft pretzels!

    *量词quantExample使用时会返回一些奇怪的匹配项,因此我们可以使用quantExample省略一个示例。 在下面的示例中,我们将看到在野餐时有人带上多个单词名称的食品时如何应用它。 没有它,我们将无法正确地捕捉到安娜带来的软椒盐脆饼!

    Let’s combine what we know so far about character sets, meta characters, and quantifiers to answer some questions about our picnic string. We want to know all of the words that are in the string and also the numbers in the string.

    让我们结合到目前为止对字符集,元字符和量词的了解,回答一些有关野餐字符串的问题。 我们想知道字符串中的所有单词以及字符串中的数字。

    For words, we can use a character set with all upper and lower case letters, adding a + quantifier to it. This will find any length of alpha characters grouped together. Said another way, it finds all of the words. Regex is starting to look much more helpful.

    对于单词,我们可以使用所有大写和小写字母的字符集,并为其添加一个+量词。 这将找到组合在一起的任意长度的字母字符。 换句话说,它找到所有单词。 正则表达式开始看起来更加有用。

    [[1]]
    [1] "Drew" "has" "watermelons" "Alex"
    [5] "has" "hamburgers" "Karina" "has"
    [9] "tamales" "and" "Anna" "has"
    [13] "soft" "pretzels"

    To find the quantity of each food item, we can use the \\d meta character and the quantifier {1,2}. This will find the groups of digits that are 1 or 2 characters long. This is a much more useful output as we have the same number of quantities as we have food items and people!

    要找到每种食品的数量,我们可以使用\\d元字符和量词{1,2} 。 这将找到1或2个字符长的数字组。 这是一个非常有用的输出,因为我们拥有的数量与食物和人的数量相同!

    [[1]]
    [1] "3" "4" "12" "6"

    To find the quantity and name of each food item, we can combine quantifiers with meta characters. We know that each number has a food item directly after it, so we can just add on to the previous example. We know there is a space and a word (\\s\\w+) that could be followed by another word like how “soft pretzel” appears. To specify the second word might not be there, we can use the * quantifier with the second word. Just like that we have a list containing the quantity and name of every good at our picnic.

    为了找到每种食品的数量和名称,我们可以将量词与元字符结合使用。 我们知道每个数字都紧随其后有一个食品,因此我们可以在前面的示例中添加一个食品。 我们知道有一个空格和一个单词( \\s\\w+ ),后面可以跟另一个单词,例如“软椒盐脆饼”的显示方式。 要指定第二个单词可能不存在,可以对第二个单词使用*量词。 就像这样,我们有一个清单,其中包含野餐中每种商品的数量和名称。

    [[1]]
    [1] "3 watermelons" "4 hamburgers" "12 tamales"
    [4] "6 soft pretzels"

    捕获组 (Capture Groups)

    Capture groups allow you to look for entire phrases and only return parts of them. With our example, I want each person’s name, what they are bringing, and how much of it they are bringing. Up until this point we have been using str_extract_all. It has a clean output that is easy to read for our examples, but it doesn’t actually work with capture groups. Helpfully, stringr provides str_match_all which does work with capture groups. It does however output the results in a list containing a matrix as opposed to a list containing a vector.

    捕获组使您可以查找整个短语,只返回其中的一部分。 在我们的示例中,我想要每个人的名字,他们带来的东西以及他们带来多少。 到目前为止,我们一直在使用str_extract_all 。 它具有清晰的输出,对于我们的示例而言很容易阅读,但实际上不适用于捕获组。 str_match_all是, stringr提供了str_match_all ,它可以与捕获组一起使用。 但是,它确实将结果输出到包含矩阵的列表中,而不是包含矢量的列表中。

    [[1]]
    [,1]
    [1,] "Drew has 3 watermelons"
    [2,] "Alex has 4 hamburgers"
    [3,] "Karina has 12 tamales"
    [4,] "Anna has 6 soft pretzels"

    The regex we used in captureGroup1 is looking for a name, which starts with a capital letter and has any amount of lowercase letters after it ([A-Z][a-z]+). Then after a space it matches the pattern space, word, space \\s\\w+\\s. Next we are looking for a 1 to 2 digit number followed by a space and a word (\\d{1,2}\\s\\w+). You can see in the output each row of the matrix is a character string with the details for each person.

    我们在captureGroup1使用的正则表达式正在寻找一个名称,该名称以大写字母开头, captureGroup1任意数量的小写字母( [AZ][az]+ )。 然后,在空格之后,它与模式空格,单词,空格\\s\\w+\\s匹配。 接下来,我们要寻找一个1到2位的数字,后跟一个空格和一个单词( \\d{1,2}\\s\\w+ )。 您可以在输出中看到矩阵的每一行都是一个字符串,其中包含每个人的详细信息。

    Now this is a big step up from where we started, but we don’t really care about the word “has”, and we want to be able to make a data frame out of the quantities. Let’s add in capture groups. By using capture groups, we can return a matrix where each column contains a specific piece of information. We’ll create capture groups containing each name, quantity, and item. Capture groups are simply sections of the regex that you wrap in parenthesis.

    现在这是从我们开始的地方迈出的一大步,但我们并不真正在乎“有”一词,我们希望能够从数量上制造出一个数据框架。 让我们添加捕获组。 通过使用捕获组,我们可以返回一个矩阵,其中每一列都包含特定的信息。 我们将创建包含每个名称,数量和项目的捕获组。 捕获组只是您用括号括起来的正则表达式的一部分。

    [[1]]
    [,1] [,2] [,3] [,4]
    [1,] "Drew has 3 watermelons" "Drew" "3" "watermelons"
    [2,] "Alex has 4 hamburgers" "Alex" "4" "hamburgers"
    [3,] "Karina has 12 tamales" "Karina" "12" "tamales"
    [4,] "Anna has 6 soft pretzels" "Anna" "6" "soft pretzels"

    The first column in the matrix has the entire regex, ignoring the capture groups. The remaining columns of the matrix each correspond to the capture groups we defined for name, quantity, and item.

    矩阵的第一列具有整个正则表达式,而忽略捕获组。 矩阵的其余各列分别对应于我们为名称,数量和项目定义的捕获组。

    将我们的文本合并到数据框中 (Combining our Text into a Data Frame)

    When doing data analysis, one of the most useful R data structures is a data frame. No doubt you already knew this if you clicked on this article. Data frames enable things like calculating column statistics and plotting data. Since we have a matrix with all of the information we want, turning it into a data frame isn’t too hard. We will use the data.frame function on everything except for the first column of the matrix. data.frame gives default columns names, so we will change those to match up to what is in each column.

    进行数据分析时,最有用的R数据结构之一是数据帧。 毫无疑问,如果您单击本文,您已经知道这一点。 数据框使诸如计算列统计信息和绘制数据之类的事情成为可能。 由于我们拥有一个包含所有所需信息的矩阵,因此将其转换为数据帧并不难。 我们将在矩阵的第一列以外的所有内容上使用data.frame函数。 data.frame提供了默认的列名称,因此我们将对其进行更改以匹配每列中的名称。

    A quick note on the notation: the first set of brackets after captureGroup2 ([[1]]) accesses the first element of the list, our matrix. The second set of brackets ( [,-1]) selects all rows and every column except the first one.

    关于该符号的快速注释: captureGroup2 ( [[1]] )之后的第一组括号访问列表的第一个元素,即矩阵。 第二组括号( [,-1] )选择所有行和第一列以外的每一列。

    |   | Name   | Quantity | Item          |
    | - | ------ | -------- | ------------- |
    | 1 | Drew | 3 | watermelons |
    | 2 | Alex | 4 | hamburgers |
    | 3 | Karina | 12 | tamales |
    | 4 | Anna | 6 | soft pretzels |

    结论和进一步学习 (Conclusion and Further Learning)

    We only covered a small subset of how regex can help handle unstructured text data. This is a good foundation to get started, but before long you will need to know concepts like how to find everything BUT a character (negation) or find something immediately before or after something else (lookarounds). Depending on your use case you may need to understand how lazy and greedy matching operate. Here are some more resources to help you learn more about these other concepts in regex:

    我们仅介绍了正则表达式如何帮助处理非结构化文本数据的一小部分。 这是入门的良好基础,但是不久之后,您将需要了解诸如如何找到所有字符(否定),或在其他事物之前或之后找到事物(环顾四周)之类的概念。 根据您的用例,您可能需要了解惰性匹配和贪婪匹配的工作方式。 以下是一些更多资源,可帮助您了解正则表达式中的其他概念:

    • The official stringr page on the tidyverse site: The folks over at RStudio have compiled resources to help learn packages like stringr. They even included a stringr cheat sheet that you can print out and reference.

      官方 stringr 在tidyverse网站页面 :超过乡亲RStudio已编制资源来帮助学会像包stringr 。 他们甚至还提供了更stringr 备忘单 ,您可以将其打印出来并参考。

    • R for Data Science: Written by Hadley Wickham, author of the stringr package, this book is a good reference for anything in R. There is even a chapter that covers more advanced regex in R. It is available online for free here, or you can purchase a hardcopy here. Disclaimer: I receive a commission of your purchase through this link.

      R for Data Science :由stringr软件包的作者Hadley Wickham撰写,这本书是R中任何内容的很好参考。甚至有一章涵盖了R中更高级的正则表达式。可以在此处免费在线获取,或者您可以可以在这里购买纸质版。 免责声明:我会通过此链接收取您的购买佣金

    • Datacamp Courses: An online learning community dedicated to data science, machine learning, and data visualization. Check out their course “String Manipulation with stringr in R.” The first chapter of every course on the site is free! Disclaimer: You will receive a discount on your subscription and I receive a commission if you sign up for a monthly Datacamp subscription using this link. Support my writing while you learn!

      Datacamp课程 :在线学习社区,致力于数据科学,机器学习和数据可视化。 查看他们的课程“在R中使用Stringr进行字符串操作”。 网站上每门课程的第一章都是免费的! 免责声明:如果您使用 链接 注册Datacamp的每月订阅,您将获得订阅折扣,并且我将获得佣金 在学习的同时支持我的写作!

    As always, let me know if you enjoyed the content. Don’t like how I use regex? Tell me about it in the comments. Either way, subscribe so you get notified every time I post new content!

    与往常一样,让我知道您是否喜欢其中的内容。 不喜欢我如何使用正则表达式? 在评论中告诉我。 无论哪种方式,都可以订阅,这样我每次发布新内容时都会收到通知!

    翻译自: https://towardsdatascience.com/a-gentle-introduction-to-regular-expressions-with-r-df5e897ca432

    简单正则表达式

    展开全文
  • Java正则表达式学习(一)1.什么是正则表达式:...许多程序设计语言都支持利用正则表达式进行字符串操作。正则表达式这个概念最初是由Unix中工具软件(例如sed和grep)普及开来的。正则表达式通常缩写成"regex"。2.ja...

    Java正则表达式学习(一)

    1.什么是正则表达式:

    正则表达式(regular expressions) 是一种描述字符串集的方法,它是以字符串集中各种字符串的公有特征为依据的。

    正则表达式可以用于搜索、编辑或者操作文本和数据。许多程序设计语言都支持利用正则表达式进行字符串操作。

    正则表达式这个概念最初是由Unix中工具软件(例如sed和grep)普及开来的。正则表达式通常缩写成"regex"。

    2.java.util.regex包是如何描述正则表达式的?

    java.util.regex 包主要由三个类所组成:Parten、Matcher和PatternSyntaxException。

    Pattern 对象表示一个已编译的正则表达式。Patter类没有提供公有的构造方法。要构造一个模型,首先必须调用公共的静态compile方法,它将返回一个Pattern对象。这个方法接受正则表达式作为第一个参数。

    Matcher 是一个靠着输入的字符串来解析这个模式和完成匹配操作的对象。与Pattern相似,Matcher也没有定义公共的构造方法,需要通过调用Pattern对象的matcher方法来获得一个Matcher对象。

    PatternSyntaxException 对象是一个未检查异常,指示了正则表达式中的一个语法错误。

    测试正则表达式工具,java版

    在后面的实例中,可通过该工具来验证

    package com.fortune.test;

    import java.io.Console;

    import java.util.Scanner;

    import java.util.regex.Matcher;

    import java.util.regex.Pattern;

    /**

    * Created with IntelliJ IDEA.

    * User: Alan

    * Date: 12-5-28

    * Time: 下午1:46

    */

    public class RegexTestHarness {

    public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);

    while (true) {

    System.out.printf("%nEnter your regex: ");

    Pattern pattern = Pattern.compile(scanner.nextLine());

    System.out.printf("Enter input string to search: ");

    Matcher matcher = pattern.matcher(scanner.nextLine());

    boolean found = false;

    while (matcher.find()) {

    System.out.printf(

    "I found the text \"%s\" starting at index %d and ending at index %d.%n",

    matcher.group(), matcher.start(), matcher.end()

    );

    found = true;

    }

    if (!found) {

    System.out.printf("No match found.%n");

    }

    }

    }

    }

    3.字符串验证

    在大多数的情况下,API所支持模式匹配的基本形式是匹配字符串,如果正则表达式是foo,输入的字符串也是foo,这个匹配将会是成功的。因为这两个字符串是相同的。试着用测试工具来测试一下:

    Enter your regex: foo

    Enter input string to search: foo

    I found the text "foo" starting at index 0 and ending at index 3.

    结果确实是成功的。注意当输入的字符串是3个字符长度的时候,开始的索引时0,结束的索引是3。这个是约定俗成的,范围包括开始的索引,不包括结束的索引,如下图所示:

    232304254.gif

    图1  字符串"foo"的单元格编号和索引值

    字符串中每一个字符位于其自身的单元格(cell)中,在每一单元格之间有索引指示位。字符串"foo"始于索引0处,止于索引3处,即使是这些字符它们自己仅占据了0、1和2号单元格。

    就子序列匹配而言,你会注意到一些重叠,下一次匹配开始索引与前一次匹配的结果索引是相同的:

    Enter your regex: foo

    Enter input string to search: foofoofoo

    I found the text "foo" starting at index 0 and ending at index 3.

    I found the text "foo" starting at index 3 and ending at index 6.

    I found the text "foo" starting at index 6 and ending at index 9.

    4.元字符验证

    API也支持许多可以影响模式匹配的特殊字符。把正则表达式改成 cat.  , 并输入字符串"cats",输出结果是下所示:

    Enter your regex: cat.

    Enter input string to search: cats

    I found the text "cats" starting at index 0 and ending at index 4.

    虽然在输入的字符串中没有点(.),但这个匹配仍然是成功的。这是由于点(.)是一个元字符(metacharacters)(被这个匹配翻译成了具有特殊意义的字符了)。这个例子为什么能匹配在于, 元字符.指的是"任意字符".

    API所支持的元字符有:([{\^-$|}])?*+.

    注意:在学习过更多的如何构建正则表达式后,你会碰见这些情况:上面的这些特殊字符不应该被处理为元字符。然而也能够使用这一清单来检查一个特殊的字符是否会被认为是元字符。例如,字符!、@和#绝不会有特殊意义。

    有两种方式可以强制将元字符处理成为普通字符:

    1.在元字符前加上反斜线(\);

    2.把它放在\Q(引用开始) 和 \E(引用结束)之间。在使用这种技术时,\Q 和\E能被放于表达式中的任何位置

    5.字符类匹配

    如果你曾看过Pattern类的说明,会看到一些构建正则表达式的概述。在这一节中你会发现一下的一些表达式:

    字符类

    [abc]

    a, b 或 c(简单类)

    [^abc]

    除 a, b 或 c 之外的任意字符(取反)

    [a-zA-Z]

    a 到 z,或 A 到 Z,包括(范围)

    [a-d[m-p]]

    a 到 d,或 m 到 p:[a-dm-p](并集)

    [a-z&&[def]]

    d,e 或 f(交集)

    [a-z&&[^bc]]

    除 b 和 c 之外的 a 到 z 字符:[ad-z](差集)

    [a-z&&[^m-p]]

    a 到 z,并且不包括 m 到 p:[a-lq-z](差集)

    左边列指定正则表达式构造,右边列描述每个构造的匹配的条件

    注意:"字符类(character class)"这个词中的"类(class)"指的并不是一个.class文件。在正则表达式的语义中,字符类是指放在方框号里的字符集,指定了一些字符中的一个能被给定的字符串所匹配。

    5.1 简单类(Simple Classes)

    字符类最基本的格式是把一些字符放到一个方框号内。例如:正则表达式[bcr]at 会匹配"bat"、"cat"或者"rat",这是由于其定义了一个字符类(接受"b","c"或"r"中的一个字符)作为它的首字符。

    Enter your regex: [bcr]at

    Enter input string to search: bat

    I found the text "bat" starting at index 0 and ending at index 3.

    Enter your regex: [bcr]at

    Enter input string to search: cat

    I found the text "cat" starting at index 0 and ending at index 3.

    Enter your regex: [bcr]at

    Enter input string to search: rat

    I found the text "rat" starting at index 0 and ending at index 3.

    在上面的例子中,在第一个字符匹配字符类中所定义字符类中的一个时,整个匹配就是成功的。

    5.1.1 否定匹配

    要匹配除那些列表之外所有的字符时,可以在字符类的开始处加上^元字符,这种就被称为否定(negation).

    Enter your regex: [^bcr]at

    Enter input string to search: bat

    No match found.

    Enter your regex: [^bcr]at

    Enter input string to search: cat

    No match found.

    Enter your regex: [^bcr]at

    Enter input string to search: hat

    I found the text "hat" starting at index 0 and ending at index 3.

    在输入字符串中的第一个字符不包括在字符类中所定义字符中的一个时,匹配是成功的。

    5.1.2 范围

    有时会想要定义一个包含范围的字符类,诸如,"a到h"的字母或者是"1"到"5"的数字。指定一个范围,只要在匹配的首字符和末字符间插入-元字符,比如:[1-5] 或者是 [a-h] 。也可以在类里每个的边上放置不同的范围来提高匹配的可能性,例如:[a-zA-Z]将会匹配a到z(小写字母)或者A到Z(大写字母)中任何一个字符。

    下面是一些范围和否定的例子:

    Enter your regex: [a-c]

    Enter input string to search: a

    I found the text "a" starting at index 0 and ending at index 1.

    Enter your regex: [a-c]

    Enter input string to search: b

    I found the text "b" starting at index 0 and ending at index 1.

    Enter your regex: [a-c]

    Enter input string to search: c

    I found the text "c" starting at index 0 and ending at index 1.

    Enter your regex: [a-c]

    Enter input string to search: d

    No match found.

    Enter your regex: foo[1-5]

    Enter input string to search: foo1

    I found the text "foo1" starting at index 0 and ending at index 4.

    Enter your regex: foo[1-5]

    Enter input string to search: foo5

    I found the text "foo5" starting at index 0 and ending at index 4.

    Enter your regex: foo[1-5]

    Enter input string to search: foo6

    No match found.

    Enter your regex: foo[^1-5]

    Enter input string to search: foo6

    I found the text "foo6" starting at index 0 and ending at index 4.

    5.1.3 并集

    可以使用并集(union)来建一个由两个或两个以上字符类所组成的单字符类。构建一个并集,只要在一个字符类的边上嵌套另外一个,比如:[0-4[6-8]],这种奇特方式构建的并集字符类,可以匹配0,1,2,3,4,6,7,8这几个数字。

    Enter your regex: [0-4[6-8]]

    Enter input string to search: 0

    I found the text "0" starting at index 0 and ending at index 1.

    Enter your regex: [0-4[6-8]]

    Enter input string to search: 5

    No match found.

    Enter your regex: [0-4[6-8]]

    Enter input string to search: 6

    I found the text "6" starting at index 0 and ending at index 1.

    Enter your regex: [0-4[6-8]]

    Enter input string to search: 8

    I found the text "8" starting at index 0 and ending at index 1.

    Enter your regex: [0-4[6-8]]

    Enter input string to search: 9

    No match found.

    5.1.4 交集

    建一个仅仅匹配自身嵌套类中公共部分字符的字符类时,可以像[0-9&&[345]]中那样使用&&.这种方式构建出来的交集(intersection)简单字符类,仅仅以匹配两个字符类的3,4,5共有部分。

    Enter your regex: [0-9&&[345]]

    Enter input string to search: 3

    I found the text "3" starting at index 0 and ending at index 1.

    Enter your regex: [0-9&&[345]]

    Enter input string to search: 4

    I found the text "4" starting at index 0 and ending at index 1.

    Enter your regex: [0-9&&[345]]

    Enter input string to search: 5

    I found the text "5" starting at index 0 and ending at index 1.

    Enter your regex: [0-9&&[345]]

    Enter input string to search: 2

    No match found.

    Enter your regex: [0-9&&[345]]

    Enter input string to search: 6

    No match found.

    下面演示两个范围交集的例子:

    Enter your regex: [2-8&&[4-6]]

    Enter input string to search: 3

    I found the text "3" starting at index 0 and ending at index 1.

    Enter your regex: [2-8&&[4-6]]

    Enter input string to search: 4

    I found the text "4" starting at index 0 and ending at index 1.

    Enter your regex: [2-8&&[4-6]]

    Enter input string to search: 5

    I found the text "5" starting at index 0 and ending at index 1.

    Enter your regex: [2-8&&[4-6]]

    Enter input string to search: 6

    I found the text "6" starting at index 0 and ending at index 1.

    Enter your regex: [2-8&&[4-6]]

    Enter input string to search: 7

    No match found.

    5.1.5 差集

    最后,可以使用差集(subtraction)来否定一个或多个嵌套的字符类,比如:[0-9&&[^345]], 这个是构建一个匹配除3,4,5之外所有0-9间数字的简单字符类。

    Enter your regex: [0-9&&[^345]]

    Enter input string to search: 2

    I found the text "2" starting at index 0 and ending at index 1.

    Enter your regex: [0-9&&[^345]]

    Enter input string to search: 3

    No match found.

    Enter your regex: [0-9&&[^345]]

    Enter input string to search: 4

    No match found.

    Enter your regex: [0-9&&[^345]]

    Enter input string to search: 5

    No match found.

    Enter your regex: [0-9&&[^345]]

    Enter input string to search: 6

    I found the text "6" starting at index 0 and ending at index 1.

    Enter your regex: [0-9&&[^345]]

    Enter input string to search: 9

    I found the text "9" starting at index 0 and ending at index 1.

    到此为止,已经涵盖了如何建立字符类的部分。

    6.预定义字符类

    Pattern的API包有许多有用的预定义字符类(predefined character classes),提供了常用正则表达式的简写形式

    预定义字符类

    .

    任何字符(匹配或者不匹配行结束符)

    \d

    数字字符:[0-9]

    \D

    非数字字符:[^0-9]

    \s

    空白字符:[\t\n\x0B\f\r]

    \S

    非空白字符:[^\s]

    \w

    单词字符:[a-zA-Z_0-9]

    \W

    非单词字符:[^\w]

    上表中,左列是构造右边字符类的简写形式。例如:\d指的是数字范围(0-9),\w指的是单词字符(任何大小写、下划线或者是数字)。无论何时都有可能使用预定义字符类,它可以使代码更易阅读,更易从难看的字符类中排除错误。

    以反斜线(\) 开始的构造称为构造(escaped constructs)。回顾一下在字符串中一节中的转义构造,在那里我们提及了使用反斜线,以及用于引用的\Q和\E。在字符串中使用转义构造,必须在一个反斜线前在增加一个反斜线用于字符串的编译,例如:

    private final String REGEX="\\d";

    这个例子中\d是正则表达式,另外的那个反斜线是用于代码编译所必须的。但是测试工具读取的表达式,是直接从控制台中输入的,因此不需要那个多出来的反斜线。

    下面的例子说明了预定义字符类的用法:

    Enter your regex: .

    Enter input string to search: @

    I found the text "@" starting at index 0 and ending at index 1.

    Enter your regex: .

    Enter input string to search: 1

    I found the text "1" starting at index 0 and ending at index 1.

    Enter your regex: .

    Enter input string to search: a

    I found the text "a" starting at index 0 and ending at index 1.

    Enter your regex: \d

    Enter input string to search: 1

    I found the text "1" starting at index 0 and ending at index 1.

    Enter your regex: \d

    Enter input string to search: a

    No match found.

    Enter your regex: \D

    Enter input string to search: 1

    No match found.

    Enter your regex: \D

    Enter input string to search: a

    I found the text "a" starting at index 0 and ending at index 1.

    Enter your regex: \s

    Enter input string to search:

    No match found.

    Enter your regex: \s

    Enter input string to search: a

    No match found.

    Enter your regex: \s

    Enter input string to search: " "

    I found the text " " starting at index 1 and ending at index 2.

    Enter your regex: \S

    Enter input string to search: a

    I found the text "a" starting at index 0 and ending at index 1.

    Enter your regex: \w

    Enter input string to search: a

    I found the text "a" starting at index 0 and ending at index 1.

    Enter your regex: \w

    Enter input string to search: !

    No match found.

    Enter your regex: \W

    Enter input string to search: !

    I found the text "!" starting at index 0 and ending at index 1.

    在开始的三个例子中,正则表达式是最简单的,.("点"元字符)表示"任意字符",因此,在所有的三个例子(随意选取了"@"字符,数字和字母)中都是匹配成功的。在接下来的例子中,都使用了预定义的字符类表格中的单个正则表达式构造。你应该可以根据这张表指出前面每个匹配的逻辑:

    \d 匹配数字字符

    \s 匹配空白字符

    \w 匹配单词字符

    也可以使用意思正好相反的大写字母:

    \D 匹配非数字字符

    \S 匹配非空白字符

    \W 匹配非单词字符

    展开全文
  • 正则表达式基本规则与Java正则表达式使用 正则表达式匹配规则 介绍正则表达式基本匹配规则,即正则表达式字符的匹配原则以及贪婪匹配与非贪婪匹配的区别及实例。 正则表达式集及举例 字符 描述 \ 将下一个...
  • 正则表达式pythonWe live in an information age where large volumes of data abound and the ability to extract meaningful information from data is a key differentiator for success. Fields such as ...
  • 程序设计语言处理正则表达式的方式 集成式:表达式直接内建在语言之中,如Perl 程序式和面向对象式:正则表达式不属于语言的低级语法。相反,普通的函数接受普通的字符串,把他们作为正则表达式进行处理。 集成式...
  • scala 正则表达式Regular expressions are pattern matching utilities found in most of the programming languages. They define a generic pattern to match a sequence of input characters. Regex are widely ...
  • 使用Matcher类,最重要的一个概念必须清楚:组(Group),在正则表达式中 ()定义了一个组,由于一个正则表达式可以包含很多的组,所以下面先说说怎么划分组的, 以及这些组和组的下标怎么对应的. 下面我们看看一个小例子,...
  • scala 正则表达式匹配 前言 这是面向初学者的Scala教程的第5部分。... 这篇文章是有关正则表达式(regexes)的两个文章中的第一篇,正则表达式对于各种编程任务,尤其是计算语言学任务都是必不可少的。 本教程介绍...
  • Java 正则表达式

    万次阅读 多人点赞 2018-08-31 23:08:12
    介绍 前段时间使用Java的正则表达式做一些字符串匹配的任务,现将学到的正则表达式的知识整理成文。...Java中更一般使用正则表达式的方式是利用Pattern.class和Matcher.class,所在package为java.util.regex J...
  • 正则表达式科学计数法As data scientists, diving headlong into huge heaps of data is part of the mission. Sometimes, this includes massive corpuses of text. For instance, suppose we were asked to figure...
  • 正则表达式用于字符串处理、表单验证、文本操作等应用场合 一、Java正则表达式编程主要的相关类 java.util.regex.Pattern  没有构造方法,由Pattern类静态方法compile(String regex)将给定的正则表达式编译到模式中...
  • 正则表达式

    2021-05-28 17:49:45
    目录正则表达式基本介绍正则表达式底层实现正则表达式语法基本介绍元字符功能详解转义字符匹配符选择匹配符限定符定位符分组正则表达式的三个常用类Pattern类Matcher类PatternSyntaxException类分组、捕获、反向引用...
  • 1、匹配功能 Scala 通过 scala.util.matching 包中...你可以使用 mkString( ) 方法来连接正则表达式匹配结果的字符串,并可以使用管道(|)来设置不同的模式:package DataStructureAndAlgorithm/** * Created by Admin
  • 理解正则表达式

    2021-04-09 16:02:25
    文章目录一、正则表达式1、正则表达式1.1、Java正则表达式1.2.Java正则类封装1.3 Pattern类匹配使用1.4 Matcher类匹配使用 一、正则表达式 1、正则表达式 正则表达式定义了字符串的模式。 正则表达式可以用来...
  • https://stat545.com/block022_regular-expression.html END
  • 正则表达式正则表达式其实就是用于操作字符串的一个规则,使用特殊的符号表示; 需求: 校验一个QQ号: 1、不能以0开头; 2、长度为5~12位; 3、只能由数字组成; */ public class Demo1 { // String qq...
  • Java正则表达式

    2020-01-28 22:21:39
    * 正则表达式是描述规则,主流语言都有良好支持 * 字符串校验、查找与替换是正则表达式主要使用场景 2. 正则表达式字符范围匹配 正则表达式区分大小写 tool.oschina.net/regex 开源中国提供的正则表达式在线...
  • 正则表达式引擎 源码 c#Download Regex - 71.7KB 下载Regex-71.7 KB Download latest from GitHub 从GitHub下载最新版本 更新: (Update:) See my Unicode enabled offering here 在这里查看启用Unicode的产品 ...
  • 正则表达式是一个独立的技术,很多语言都支持他 字符类 [abc] a、b 或 c(简单类) [^abc] 任何字符,除了 a、b 或 c(否定) [a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内(范围) [a-d[m-...
  • 本文实例讲述了Go语言正则表达式。分享给大家供大家参考,具体如下: 代码如下:package main import “bytes” import “fmt” import “regexp” func main() { //这个测试一个字符串是否符合一个表达式。  match...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,969
精华内容 7,587
关键字:

packager正则表达式