精华内容
下载资源
问答
  •  java 正则表达式默认用的是greedy贪婪匹配模式既是这种类型(.*)的最长匹配,如果需要最短匹配则改为(.*?)即是勉强匹配模式。 原理分析:  如果是贪婪匹配模式正则表达式引擎会一直匹配到字符串最后,当匹配为...

    解释:

         greedy :贪婪

         reluctant:勉强,不情愿

          java 正则表达式默认用的是greedy贪婪匹配模式既是这种类型(.*)的最长匹配,如果需要最短匹配则改为(.*?)即是勉强匹配模式。

    原理分析:

          如果是贪婪匹配模式,正则表达式引擎会一直匹配到字符串最后,当匹配为false时,通过
    回溯的方式,倒退找到倒数第一个匹配位置,返回匹配结果

          如果是勉强匹配模式,正则表达式引擎会匹配到符合pattern的末尾位置那个字符,然后再往后走一步,发现匹配为false,又回溯到找到回退的最近一个匹配为true的位置,返回结果。

    看代码:

    例一:

    @Test
    	public void test51(){
    		String str = "aaa\"bbb\"ccc\"ddd\"eee";
    		System.out.println(str);
    		str = str.replaceAll("\"(.*)\"", "@");
    		System.out.println(str);
    	}


    输出:

    aaa"bbb"ccc"ddd"eee
    aaa@eee

    例二:

    	@Test
    	public void test52(){
    		String str = "aaa\"bbb\"ccc\"ddd\"eee";
    		System.out.println(str);
    		
    		str = str.replaceAll("\"(.*?)\"", "@");
    		System.out.println(str);
    		
    	}


    输出:

    aaa"bbb"ccc"ddd"eee
    aaa@ccc@eee

    例三:

    @Test
    	public void test7(){
    		// Greedy quantifiers
    	    String match = find("A.*c", "AbcAbc");  // AbcAbc
    	    System.out.println(match);
    	    match = find("A.+", "AbcAbc");          // AbcAbc
    	    System.out.println(match);
    	    // Nongreedy quantifiers
    	    match = find("A.*?c", "AbcAbc");        // Abc
    	    System.out.println(match);
    	    match = find("A.+?", "AbcAbc");         // Ab
    	    System.out.println(match);
    
    	}
    	
    	public  String find(String patternStr, CharSequence input) {
            Pattern pattern = Pattern.compile(patternStr);
            Matcher matcher = pattern.matcher(input);
            if (matcher.find()) {
                return matcher.group();
            }
            return null;
        }



     


     

     

     

     

    展开全文
  • 主要介绍了Java 正则表达式匹配模式(贪婪型、勉强型、占有型),需要的朋友可以参考下
  • 正则表达式贪婪模式、懒惰模式与独占模式浅析 一、正则表达式引擎:       正则表达式的执行,是由正则表达式引擎编译执行的,正则表达式引擎分为DFA(Deterministic finite automaton...

    正则表达式贪婪模式、懒惰模式与独占模式浅析

    一、正则表达式引擎:

          正则表达式的执行,是由正则表达式引擎编译执行的,正则表达式引擎分为DFA(Deterministic finite automaton,确定型有穷自动机)和NFA(Non-deterministic finite automaton,非确定型有穷自动机)两类,确定型即在没有正则表达式时就可以确定的按照文本顺序直接确定匹配的顺序,非确定型的文本匹配顺序则与所编写的正则表达式有关,因此,我们可以认为DFA是由文本主导的,而NFA是由正则表达式主导的。
          在使用DFA时,引擎会按照从左到右的顺序直接进行匹配,也就是说每处的匹配只会进行一次,在这种情况下,执行速度会更快,但是它的缺点也很明显,支持的特性较少,无法支持捕获组,反向引用等功能,而且在比较诸如(a|b|c|d|…)会同时将这些情况同时拿出来比较,十分占用资源,如果表达式写的不合理,会造成机器崩溃等后果。
          在使用NFA时,引擎会根据正则表达式来匹配文本,它会不断读入字符,尝试是否符合当前正则表达式,如果不符合,会吐出字符重新尝试,通常情况下会慢于DFA,但是NFA能支持DFA不能支持的一些非常方便的特性,如上面提到的捕获组和反向引用等。因此,为了编程方便,在实际学习工作中应用更多。
          通过匹配原理我们可以看出DFA是以功能和资源占用为代价换取了匹配速度,而NFA正好与之相反。由于上面只是讲了原理不够直观,下面具体举例进行说明。

    String text = "hi Tom,hello"
    String regex = "he(l|la|lb|lc|ll)o"
    

          在DFA时,引擎会先寻找第一个h,然后寻找h后面的e,发现第一个h处匹配失败,直接放弃,去寻找第二个h,再寻找后面的e,发现可以匹配,遇到(l|la|lb|lc|ll) 后开始同时进行几个条件的匹配,即并行匹配,如果几个条件均不符合则放弃此处继续向后匹配,如果找到合适的,就会继续匹配表达式的剩余条件,由于不走回头路的特性,其匹配速度一般比较快,但是并行匹配比较消耗资源,对机器性能要求高。
          在NFA时,主要区别在于对于(l|la|lb|lc|ll)这种可选条件的处理,如果第一个选项失败,则会回退到可选条件之前,重新对下一个选项进行匹配,直到找到匹配的选项,然后继续匹配选项后面表达式剩余的条件;或发现所有的选项都不匹配,然后放弃此处。
          再次强调,DFA下,任何效果相同的正则表达式匹配过程均相同;NFA下,效果相同的不同正则表达式其匹配过程可能不同。

    二、NFA的回溯机制:

          回溯,即在匹配过程中由当前位置吐出若干个字符再与正则表达式后面的条件重新进行匹配。
          举个比较经典的例子:

    String regex = "ab{1,3}c"
    

          当要匹配的字符串为abbbc时,a匹配完成后,b匹配三次,然后c进行匹配,匹配完成,整个过程中不会发生回溯。
          当要匹配的文本为’"abc"时,1~2步应该都好理解,但是为什么在第3步开始,虽然已经文本中已经有一个b匹配了b{1,3},后面还会拉着字母c跟b{1,3}做比较呢?这个就是我们下面将要提到的正则的贪婪特性,也就是说b{1,3}会竭尽所能的匹配最多的字符。在这个地方我们先知道它一直要匹配到撞上南墙为止。 在这种情况下,第3步发生不匹配之后,整个匹配流程并没有走完,而是像栈一样,将字符c吐出来,然后去用正则表达式中的c去和文本中的c进行匹配。这样就发生了一次回溯。

    在这里插入图片描述

    三、正则表达式的三种模式:

          正则表达式一共有三种模式:贪婪模式、懒惰模式和独占模式。下面分别对三种模式进行简单讨论。
          在讨论几个模式前要先讲一下可能涉及到的几个常见正则表达式元字符(此名称来自百度百科):
    i. ?:匹配前面的子表达式零次或一次;
    ii.+:匹配前面的子表达式一次或多次(大于等于1次)。
    iii.*:匹配前面的子表达式任意次。
    iv.{n,m}:即{min,max},最少匹配n次,最多匹配m次。当m省略时,则代表最少匹配n次,最多匹配次数无上限。
    a.贪婪模式:默认情况下,正则表达式的匹配都会采用贪婪模式,贪婪模式下,会尽可能多的匹配符合正则表达式的内容。
    b.懒惰模式:也称非贪婪模式,懒惰模式尽可能少地匹配所搜索的字符串,开启方法为正则表达式该部分后加上?。
    如果上面表达式改为:

    String regex = "ab{1,3}?c"
    

    则在匹配’abc’和’abbc’时均不会发生回溯,"abc"匹配过程如下:
    在这里插入图片描述
    c.独占模式:可以理解为不会回溯的贪婪模式,但是如’abc’和’abbc’用下面的表达式会出现不匹配的情况,所以建议使用的时候要慎重,除非条件比较苛刻或者对要匹配的数据或文本十分了解,但是由于这种模式下不会发生回溯,所以资源消耗较小。

    // 独占模式
    String regex = "ab{1,3}+c"
    

    "abbc"用上式的匹配过程如下图,结果是匹配不超过,去掉+即关闭独占模式后匹配成功。
    在这里插入图片描述
    下面附三种模式下常用表达式形式:

    贪婪 懒惰 独占
    x? x? x?+
    x* x*? x*+
    x+ x+? x+
    x{n} x{n}? x{n}+
    x{n,} x{n,}? x{n,}+
    x{n,m} x{n,m}? x{n,m}+
    展开全文
  • java正则表达式详解

    万次阅读 多人点赞 2019-04-02 16:35:46
    一、正则表达式术语 1)元字符 : 非一般字符,具有某种意义的字符。如 : \bX : \b边界符, 以 X开始的单词 2)正则表达式语法大全 字符 说明 \ 将下一字符标记为特殊字符...

    微信搜索:“二十同学” 公众号,欢迎关注一条不一样的成长之路

    一、正则表达式术语

     1)元字符 : 非一般字符,具有某种意义的字符。如 : \bX : \b边界符, 以 X开始的单词  

    2)正则表达式语法大全

    字符

    说明

    \

    将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,"n"匹配字符"n"。"\n"匹配换行符。序列"\\"匹配"\","\("匹配"("。

    ^

    匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与"\n"或"\r"之后的位置匹配。

    $

    匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$ 还会与"\n"或"\r"之前的位置匹配。

    *

    零次或多次匹配前面的字符或子表达式。例如,zo* 匹配"z"和"zoo"。* 等效于 {0,}。

    +

    一次或多次匹配前面的字符或子表达式。例如,"zo+"与"zo"和"zoo"匹配,但与"z"不匹配。+ 等效于 {1,}。

    ?

    零次或一次匹配前面的字符或子表达式。例如,"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。

    {n}

    是非负整数。正好匹配 n 次。例如,"o{2}"与"Bob"中的"o"不匹配,但与"food"中的两个"o"匹配。

    {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?'。注意:您不能将空格插入逗号和数字之间。

    当此字符紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串,而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如,在字符串"oooo"中,"o+?"只匹配单个"o",而"o+"匹配所有"o"。

    .

    匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式。

    (pattern)

    匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( ),请使用"\("或者"\)"。

    (?:pattern)

    匹配 pattern 但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如,'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。

    (?=pattern)

    执行正向预测先行搜索的子表达式,该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows",但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

    (?!pattern)

    执行反向预测先行搜索的子表达式,该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配,即不能捕获供以后使用的匹配。例如,'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows",但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符,即发生匹配后,下一匹配的搜索紧随上一匹配之后,而不是在组成预测先行的字符后。

    x|y

    匹配 x 或 y。例如,'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。

    [xyz]

    字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a"。

    [^xyz]

    反向字符集。匹配未包含的任何字符。例如,"[^abc]"匹配"plain"中"p","l","i","n"。

    [a-z]

    字符范围。匹配指定范围内的任何字符。例如,"[a-z]"匹配"a"到"z"范围内的任何小写字母。

    [^a-z]

    反向范围字符。匹配不在指定的范围内的任何字符。例如,"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。

    \b

    匹配一个字边界,即字与空格间的位置。例如,"er\b"匹配"never"中的"er",但不匹配"verb"中的"er"。

    \B

    非字边界匹配。"er\B"匹配"verb"中的"er",但不匹配"never"中的"er"。

    \cx

    匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样,则假定 c 就是"c"字符本身。

    \d

    数字字符匹配。等效于 [0-9]。

    \D

    非数字字符匹配。等效于 [^0-9]。

    \f

    换页符匹配。等效于 \x0c 和 \cL。

    \n

    换行符匹配。等效于 \x0a 和 \cJ。

    \r

    匹配一个回车符。等效于 \x0d 和 \cM。

    \s

    匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。

    \S

    匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。

    \t

    制表符匹配。与 \x09 和 \cI 等效。

    \v

    垂直制表符匹配。与 \x0b 和 \cK 等效。

    \w

    匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效。

    \W

    与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。

    \xn

    匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如,"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。

    \num

    匹配 num,此处的 num 是一个正整数。到捕获匹配的反向引用。例如,"(.)\1"匹配两个连续的相同字符。

    \n

    标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么 n 是反向引用。否则,如果 n 是八进制数 (0-7),那么 n 是八进制转义码。

    \nm

    标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式,那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获,则 n 是反向引用,后面跟有字符 m。如果两种前面的情况都不存在,则 \nm 匹配八进制值 nm,其中 和 m 是八进制数字 (0-7)。

    \nml

    当 n 是八进制数 (0-3),m 和 l 是八进制数 (0-7) 时,匹配八进制转义码 nml

    \un

    匹配 n,其中 n 是以四位十六进制数表示的 Unicode 字符。例如,\u00A9 匹配版权符号 (©)。

    二、Pattern类与Matcher类详解

            java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式。 Matcher 一个Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查。 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式,然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作。

    以下我们就分别来看看这两个类:

    捕获组的概念

    捕获组可以通过从左到右计算其开括号来编号,编号是从1 开始的。例如,在表达式 ((A)(B(C)))中,存在四个这样的组:

    ((A)(B(C)))
    (A)
    (B(C))
    (C)

    组零始终代表整个表达式。 以 (?) 开头的组是纯的非捕获 组,它不捕获文本,也不针对组合计进行计数。

           与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组,则在第二次计算失败时将保留其以前捕获的值(如果有的话)例如,将字符串"aba" 与表达式(a(b)?)+ 相匹配,会将第二组设置为 "b"。在每个匹配的开头,所有捕获的输入都会被丢弃。

    详解Pattern类和Matcher类

           java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳). 
           Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式, 

    Pattern p=Pattern.compile("\\w+"); 
    p.pattern();//返回 \w+ 

    pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

    1.Pattern.split(CharSequence input)

             Pattern有一个split(CharSequence input)方法,用于分隔字符串,并返回一个String[],我猜String.split(String regex)就是通过Pattern.split(CharSequence input)来实现的. 

    Pattern p=Pattern.compile("\\d+"); 
    String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com"); 

    结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com" 

    2.Pattern.matcher(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,该方法适合用于只匹配一次,且匹配全部字符串.

    Pattern.matches("\\d+","2223");//返回true 
    Pattern.matches("\\d+","2223aa");//返回false,需要匹配到所有字符串才能返回true,这里aa不能匹配到 
    Pattern.matches("\\d+","22bb23");//返回false,需要匹配到所有字符串才能返回true,这里bb不能匹配到 

    3.Pattern.matcher(CharSequence input)

             说了这么多,终于轮到Matcher类登场了,Pattern.matcher(CharSequence input)返回一个Matcher对象.
             Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例. 
             Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 

    4.Matcher.matches()/ Matcher.lookingAt()/ Matcher.find()

            Matcher类提供三个匹配操作方法,三个方法均返回boolean类型,当匹配到时返回true,没匹配到则返回false 
            matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.matches();//返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功. 
    Matcher m2=p.matcher("2223"); 
    m2.matches();//返回true,因为\d+匹配到了整个字符串

           我们现在回头看一下Pattern.matcher(String regex,CharSequence input),它与下面这段代码等价 
    Pattern.compile(regex).matcher(input).matches() 
    lookingAt()对前面的字符串进行匹配,只有匹配到的字符串在最前面才返回true 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.lookingAt();//返回true,因为\d+匹配到了前面的22 
    Matcher m2=p.matcher("aa2223"); 
    m2.lookingAt();//返回false,因为\d+不能匹配前面的aa 

    find()对字符串进行匹配,匹配到的字符串可以在任何位置. 

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("22bb23"); 
    m.find();//返回true 
    Matcher m2=p.matcher("aa2223"); 
    m2.find();//返回true 
    Matcher m3=p.matcher("aa2223bb"); 
    m3.find();//返回true 
    Matcher m4=p.matcher("aabb"); 
    m4.find();//返回false 

    5.Mathcer.start()/ Matcher.end()/ Matcher.group()

        当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息. 

    • start()返回匹配到的子字符串在字符串中的索引位置. 
    • end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置. 
    • group()返回匹配到的子字符串 
    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("aaa2223bb"); 
    m.find();//匹配2223 
    m.start();//返回3 
    m.end();//返回7,返回的是2223后的索引号 
    m.group();//返回2223 
    
    Mathcer m2=m.matcher("2223bb"); 
    m.lookingAt();   //匹配2223 
    m.start();   //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0 
    m.end();   //返回4 
    m.group();   //返回2223 
    
    Matcher m3=m.matcher("2223bb"); 
    m.matches();   //匹配整个字符串 
    m.start();   //返回0,原因相信大家也清楚了 
    m.end();   //返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串 
    m.group();   //返回2223bb 

            说了这么多,相信大家都明白了以上几个方法的使用,该说说正则表达式的分组在java中是怎么使用的. 
    start(),end(),group()均有一个重载方法它们是start(int i),end(int i),group(int i)专用于分组操作,Mathcer类还有一个groupCount()用于返回有多少组. 

    Pattern p=Pattern.compile("([a-z]+)(\\d+)"); 
    Matcher m=p.matcher("aaa2223bb"); 
    m.find();   //匹配aaa2223 
    m.groupCount();   //返回2,因为有2组 
    m.start(1);   //返回0 返回第一组匹配到的子字符串在字符串中的索引号 
    m.start(2);   //返回3 
    m.end(1);   //返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置. 
    m.end(2);   //返回7 
    m.group(1);   //返回aaa,返回第一组匹配到的子字符串 
    m.group(2);   //返回2223,返回第二组匹配到的子字符串 

    现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来,利用java的正则操作是那么的简单. 
     

    Pattern p=Pattern.compile("\\d+"); 
    Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com"); 
    while(m.find()) { 
         System.out.println(m.group()); 
    } 
    
    //输出: 
    
    456456 
    0532214 
    123 
    
    
    //如将以上while()循环替换成 
    
    while(m.find()) { 
         System.out.println(m.group()); 
         System.out.print("start:"+m.start()); 
         System.out.println(" end:"+m.end()); 
    } 
    
    //则输出: 
    
    456456 
    start:6 end:12 
    0532214 
    start:19 end:26 
    123 
    start:36 end:39 

             现在大家应该知道,每次执行匹配操作后start(),end(),group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息. 
             注意:只有当匹配操作成功,才可以使用start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用.

    三、常用的正则表达式:

    (1)    "^\d+$"  //非负整数(正整数 + 0)

    (2)    "^[0-9]*[1-9][0-9]*$"  //正整数

    (3)    "^((-\d+)|(0+))$"  //非正整数(负整数 + 0)

    (4)    "^-[0-9]*[1-9][0-9]*$"  //负整数

    (5)    "^-?\d+$"    //整数

    (6)    "^\d+(\.\d+)?$"  //非负浮点数(正浮点数 + 0)

    (7)    "^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$"  //正浮点数

    (8)    "^((-\d+(\.\d+)?)|(0+(\.0+)?))$"  //非正浮点数(负浮点数 + 0)

    (9)    "^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"  //负浮点数

    (10)  "^(-?\d+)(\.\d+)?$"  //浮点数

    (11)  "^[A-Za-z]+$"  //由26个英文字母组成的字符串

    (12)  "^[A-Z]+$"  //由26个英文字母的大写组成的字符串

    (13)  "^[a-z]+$"  //由26个英文字母的小写组成的字符串

    (14)  "^[A-Za-z0-9]+$"  //由数字和26个英文字母组成的字符串

    (15)  "^\w+$"  //由数字、26个英文字母或者下划线组成的字符串

    (16)  "^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"    //email地址

    (17)  "^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$"  //url

    (18)  /^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/   //  年-月-日

    (19)  /^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/   // 月/日/年

    (20)  "^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$"   //Emil

    (21)  /^((\+?[0-9]{2,4}\-[0-9]{3,4}\-)|([0-9]{3,4}\-))?([0-9]{7,8})(\-[0-9]+)?$/     //电话号码

    (22)  "^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$"   //IP地址

    (23)   

    (24)  匹配中文字符的正则表达式: [\u4e00-\u9fa5]

    (25)  匹配双字节字符(包括汉字在内):[^\x00-\xff]

    (26)  匹配空行的正则表达式:\n[\s| ]*\r

    (27)  匹配HTML标记的正则表达式:/<(.*)>.*<\/\1>|<(.*) \/>/

    (28)  匹配首尾空格的正则表达式:(^\s*)|(\s*$)

    (29)  匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    (30)  匹配网址URL的正则表达式:^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$

    (31)  匹配帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$

    (32)  匹配国内电话号码:(\d{3}-|\d{4}-)?(\d{8}|\d{7})?

    (33)  匹配腾讯QQ号:^[1-9]*[1-9][0-9]*$

    (34)  元字符及其在正则表达式上下文中的行为:

    (35)  \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。

    (36)  ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的Multiline 属性,^ 也匹配 ’\n’ 或 ’\r’ 之后的位置。

    (37)  $ 匹配输入字符串的结束位置。如果设置了 RegExp 对象的Multiline 属性,$ 也匹配 ’\n’ 或 ’\r’ 之前的位置。

    (38)  * 匹配前面的子表达式零次或多次。

    (39)  + 匹配前面的子表达式一次或多次。+ 等价于 {1,}。

    (40)  ? 匹配前面的子表达式零次或一次。? 等价于 {0,1}。

    (41)  {n} n 是一个非负整数,匹配确定的n 次。

    (42)  {n,} n 是一个非负整数,至少匹配n 次。

    (43)  {n,m} m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。在逗号和两个数之间不能有空格。

    (44)  ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。

    (45)  . 匹配除 "\n" 之外的任何单个字符。要匹配包括 ’\n’ 在内的任何字符,请使用象 ’[.\n]’ 的模式。

    (46)  (pattern) 匹配pattern 并获取这一匹配。

    (47)  (?:pattern) 匹配pattern 但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。

    (48)  (?=pattern) 正向预查,在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。

    (49)  (?!pattern) 负向预查,与(?=pattern)作用相反

    (50)  x|y 匹配 x 或 y。

    (51)  [xyz] 字符集合。

    (52)  [^xyz] 负值字符集合。

    (53)  [a-z] 字符范围,匹配指定范围内的任意字符。

    (54)  [^a-z] 负值字符范围,匹配任何不在指定范围内的任意字符。

    (55)  \b 匹配一个单词边界,也就是指单词和空格间的位置。

    (56)  \B 匹配非单词边界。

    (57)  \cx 匹配由x指明的控制字符。

    (58)  \d 匹配一个数字字符。等价于 [0-9]。

    (59)  \D 匹配一个非数字字符。等价于 [^0-9]。

    (60)  \f 匹配一个换页符。等价于 \x0c 和 \cL。

    (61)  \n 匹配一个换行符。等价于 \x0a 和 \cJ。

    (62)  \r 匹配一个回车符。等价于 \x0d 和 \cM。

    (63)  \s 匹配任何空白字符,包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

    (64)  \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

    (65)  \t 匹配一个制表符。等价于 \x09 和 \cI。

    (66)  \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。

    (67)  \w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。

    (68)  \W 匹配任何非单词字符。等价于 ’[^A-Za-z0-9_]’。

    (69)  \xn 匹配 n,其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。

    (70)  \num 匹配 num,其中num是一个正整数。对所获取的匹配的引用。

    (71)  \n 标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式,则 n 为后向引用。否则,如果 n 为八进制数字 (0-7),则 n 为一个八进制转义值。

    (72)  \nm 标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式,则 nm 为后向引用。如果 \nm 之前至少有 n 个获取,则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足,若 n 和 m 均为八进制数字 (0-7),则 \nm 将匹配八进制转义值 nm。

    (73)  \nml 如果 n 为八进制数字 (0-3),且 m 和 l 均为八进制数字 (0-7),则匹配八进制转义值 nml。

    (74)  \un 匹配 n,其中 n 是一个用四个十六进制数字表示的Unicode字符。

    (75)  匹配中文字符的正则表达式: [u4e00-u9fa5]

    (76)  匹配双字节字符(包括汉字在内):[^x00-xff]

    (77)  匹配空行的正则表达式:n[s| ]*r

    (78)  匹配HTML标记的正则表达式:/<(.*)>.*</1>|<(.*) />/

    (79)  匹配首尾空格的正则表达式:(^s*)|(s*$)

    (80)  匹配Email地址的正则表达式:w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*

    (81)  匹配网址URL的正则表达式:http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

    (82)  利用正则表达式限制网页表单里的文本框输入内容:

    (83)  用正则表达式限制只能输入中文:οnkeyup="value=value.replace(/[^u4E00-u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^u4E00-u9FA5]/g,''))"

    (84)  用正则表达式限制只能输入全角字符: οnkeyup="value=value.replace(/[^uFF00-uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^uFF00-uFFFF]/g,''))"

    (85)  用正则表达式限制只能输入数字:οnkeyup="value=value.replace(/[^d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

    (86)  用正则表达式限制只能输入数字和英文:οnkeyup="value=value.replace(/[W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

    (87)  整理:

    (88)  匹配中文字符的正则表达式: [\u4e00-\u9fa5]

    (89)  匹配双字节字符(包括汉字在内):[^\x00-\xff]

    (90)  匹配空行的正则表达式:\n[\s| ]*\r

    (91)  匹配HTML标记的正则表达式:/<(.*)>.*<\/\1>|<(.*) \/>/

    (92)  匹配首尾空格的正则表达式:(^\s*)|(\s*$)

    (93)  匹配IP地址的正则表达式:/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //

    (94)  匹配Email地址的正则表达式:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    (95)  匹配网址URL的正则表达式:http://(/[\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

    (96)  sql语句:^(select|drop|delete|create|update|insert).*$

    (97)  非负整数:^\d+$

    (98)  正整数:^[0-9]*[1-9][0-9]*$

    (99)  非正整数:^((-\d+)|(0+))$

    (100)  负整数:^-[0-9]*[1-9][0-9]*$

    (101)  整数:^-?\d+$

    (102)  非负浮点数:^\d+(\.\d+)?$

    (103)  正浮点数:^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$

    (104)  非正浮点数:^((-\d+\.\d+)?)|(0+(\.0+)?))$

    (105)  负浮点数:^(-((正浮点数正则式)))$

    (106)  英文字符串:^[A-Za-z]+$

    (107)  英文大写串:^[A-Z]+$

    (108)  英文小写串:^[a-z]+$

    (109)  英文字符数字串:^[A-Za-z0-9]+$

    (110)  英数字加下划线串:^\w+$

    (111)  E-mail地址:^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$

    (112)  URL:^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$

    或:^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$

    (113)  邮政编码:^[1-9]\d{5}$

    (114)  中文:^[\u0391-\uFFE5]+$

    (115)  电话号码:^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$

    (116)  手机号码:^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$

    (117)  双字节字符(包括汉字在内):^\x00-\xff

    (118)  匹配首尾空格:(^\s*)|(\s*$)(像vbscript那样的trim函数)

    (119)  匹配HTML标记:<(.*)>.*<\/\1>|<(.*) \/>

    (120)  匹配空行:\n[\s| ]*\r

    (121)  提取信息中的网络链接:(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

    (122)  提取信息中的邮件地址:\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

    (123)  提取信息中的图片链接:(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?

    (124)  提取信息中的IP地址:(\d+)\.(\d+)\.(\d+)\.(\d+)

    (125)  提取信息中的中国手机号码:(86)*0*13\d{9}

    (126)  提取信息中的中国固定电话号码:(\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}

    (127)  提取信息中的中国电话号码(包括移动和固定电话):(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}

    (128)  提取信息中的中国邮政编码:[1-9]{1}(\d+){5}

    (129)  提取信息中的浮点数(即小数):(-?\d*)\.?\d+

    (130)  提取信息中的任何数字 :(-?\d*)(\.\d+)?

    (131)  IP:(\d+)\.(\d+)\.(\d+)\.(\d+)

    (132)  电话区号:/^0\d{2,3}$/

    (133)  腾讯QQ号:^[1-9]*[1-9][0-9]*$

    (134)  帐号(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$

    (135)  中文、英文、数字及下划线:^[\u4e00-\u9fa5_a-zA-Z0-9]+$ 

     

    展开全文
  •  1) 正则表达式前面讲过了,是需要先编译再执行的,因此从某种方面来将正则表达式其实也是一种特殊的编程语言;  2) 既然是编程语言(特殊的编程与语言)那么它就有它自己的源代码字符、关键字等概念了;  3) ...

    1. 基本字符和特殊字符:

        1) 正则表达式前面讲过了,是需要先编译再执行的,因此从某种方面来将正则表达式其实也是一种特殊的编程语言;

        2) 既然是编程语言(特殊的编程与语言)那么它就有它自己的源代码字符、关键字等概念了;

        3) 正则表达式没有像其它编程语言一样的关键字(像if、else、while等),它的关键字是特殊字符,因此正则表达式的源码分为基本字符和特殊字符:

        4) 基本字符:包括所有的英文字母(大小写都包含)和数字(0-9),它们就是纯文本字符,它们只代表自己本身;

        5) 特殊字符:基本上都是一些符号字符,例如*、\、^等,它们不是纯文本字符,有特殊含义,正则表达式引擎会把它们解释成命令并编译成子函数;

        6) 这里先介绍两个最重要的特殊字符,它们在后面会有大量应用:

             i. \:转义字符,用于转义紧跟在它后面的下一个字符,使其具有特殊含义;

             ii. ():标记子表达式的开始和结束,即用()括起来的部分就是一个子表达式;


    2. 匹配单个字符:

        1) 基本字符(普通字符):所有的英文字母(包括大小写)和纯数字(0-9),之前已经讲过了;

        2) 用ASCII编码来表示字符:有两种形式,一种是8进制形式,一种是16进制形式

             i. \0XX:X表示八进制数(0-7);

             ii. \xXX:X表示十六进制数(0-9、a-f,不分大小写,,一般推荐大写,大写更美观);

    !!由于这两种形式只能表示ASCII编码,而ASCII编码范围是十进制的[0, 127],因此八进制表示法的X最多有2个,而十六进制的X最多也只有两个!!

        3) 用Unicode编码来表示字符:\uXXXX

    !!X表示十六进制数(字母不区分大小写),必须是4个X,不能缺省(ASCII码表示法可以缺省);

        4) 控制符:

             i. \t:制表

             ii. \n:换行

             iii. \r:回车

             iv. \a:报警

             v. \e:Escape

             vi. \cX:Ctrl+X,例如\cM就表示Ctrl+M,其中X是英文字母(包括大小写)


    3. 中括号表达式:范围匹配,一种特殊的匹配单个字符的方法

        1) 即[ ]表达式,用来匹配单个字符,只不过这一个字符的所在范围有中括号内的表达式来确定

        2) 枚举:[abc],表示匹配a、b、c的任意一个

        3) 范围:[a-f],表示匹配a-f之间的任意一个字符,包括边界,其中右边界一定要≥左边界,否则引擎编译错误

        4) 并:[a-cm-p],就表示a-c的范围和m-p的范围求并,其实前面的abc之类的枚举也是一种并运算

        5) 交:[a-z&&b-d],就表示a-z的范围和b-d的范围求交,结果等于[b-d]

        6) 补:[^abc]表示非a、b、c的任意一个字符,[^a-f]表示非a-f的任一字符;^也是一个脱字符,必须是中括号表达式的第一个字符,否则不起任何作用!!

    !补的是^后面紧跟的整个表达式!

        7) 嵌套:[a-m&&[def]],a-m和[def]都表示范围,因此可以做运算,结果等于[d-f]

        8) 有了上面这些基本运算,就可以构造一些很复杂的运算了:[a-z&&[^bc]] == [ad-z]

    !!但是注意不要用^构造复杂表达式,以下一些表达式将不起作用!

            a. ^后面紧跟一个[ ]嵌套:^[a-d],非法!不起任何作用

            b. ^后面是一个运算(交并补):^a-cf-h、^a-z&&c-h、^^a-c,都是非法的!!不起任何作用!!

            c. ^后面只能跟单纯的枚举和范围运算!!例如[^azh]、[^a-h]等;



    4. 前面紧邻的子表达式的重复次数:

        1) *:重复0次或多次

        2) +:重复1次或多次

    !!常用:\w+表示匹配一个单词!

        3) ?:重复0次或1次

        4) {n}:刚好重复n次

            {n,}:重复≥n次,即≥n次的都可以

            {n,m}:重复[n, m]次,即n≤  ≤m的都可以

    !!不能有任何多余的空格,否则直接编译(引擎编译)不通过;

    !!n必须为非负整数,且n≤m,否则也会引擎编译不通过;


    !!贪婪模式和勉强模式:解决重复次数匹配的歧义(就是上面的重复次数匹配)

            a. 由于重复次数的匹配可能匹配到多种结果,例如:x{2, 3}匹配xxxx,既可以匹配xx,也可以匹配xxx,因此存在歧义;

            b. 但是任何编程语言,包括正则表达式,都是不允许有任何歧义的,因此底层必定有避免歧义的机制;

            c. 正则表达式引擎默认使用贪婪模式解决歧义问题,贪婪模式:只要符合要求就一直匹配下去,直到无法匹配为止,即上面的结果就是2和3都存在,就往大的取!只取上限,包括*、+、?都是一样的,例如ab.*zz匹配abcxxzzsfewzzq的结果是abcxxzzsfewzz,并没有在abcxxzz处停止,而是直到最后的zzq不能再匹配时才停止匹配!

            d. 与贪婪模式对应的就是勉强模式:只匹配下限,即只往少的匹配,一找到符合要求的就立马匹配成功,不再管后面的序列,在勉强模式下*匹配0个,+匹配一个,?匹配0个,而{ }只匹配下限!

            f. Java是支持勉强模式的,勉强模式的表示方式是重复次数字符后面紧跟一个?,例如??就表示勉强模式的?,+?就表示勉强模式的+,*?就表示勉强模式的*,{ }?就表示勉强模式的{ };


    5. 通配符:

        1) .:匹配\r和\n之外的任意其他字符

        2) \d:匹配任意一个数字(0-9),即digit

        3) \D:匹配任意一个非数字

        4) \s:匹配任意一个空白符(制表、换行、空格、换页、回车等),即space

        5) \S:匹配任意一个非空白符

        6) \w:匹配任意一个单词字符,单词字符指0-9、26个英文字母(包括大小写)、下划线(_),注意是一个字符!而不是一个单词

        7) \W:匹配任意一个非单词字符


    6. 匹配起始和结尾:锚

        1) ^:脱字符,匹配主串的开头,即必须以^后面紧跟的子表达式为开头,例如^abc可以匹配abcxxx,group的返回结果是abc

        2) $:锚字符,匹配主串的结尾,即必须以$前面紧跟的子表达式结尾,例如abc$可以匹配qqqxxabc,group的返回结果是abc

        3) 组合锚点:例如,^book.*end$可以匹配所有以book起始以end结尾的子串

        4) 脱字符必须作为模式串的起始,锚字符必须作为$模式串的结束,否则将不会起到任何作用!!

    !例如,abc^xq并不能匹配abcxquuu,而abc$zx并不能匹配abczxddd!!


    7. 匹配单词边界:boundary

        1) \b:前面紧邻的子表达式必须是单词的边界(单词之间用空白符分隔),例如:ok\b可以匹配"book lala"中的book的ok,但不能匹配"books lala",group返回的也是ok

        2) \B:前面紧邻的子表达式必须“不是”单词的边界,例如:ok\B可以匹配"books lala"中的books的ok,但不能匹配"book lala",group返回的也是ok


    8. 或运算:|

        1) 表示指定两项(表达式)之间任选一项,即或运算;

        2) 例如a|b等于[ab],(public)|(private)就表示这两个单词任意匹配一个,但最好不要写成public|private,这可能表示匹配publicrivate或者publiprivate,有些引擎就会判定歧义;

    !!良好的习惯:自己不确定是否产生歧义的时候就加一下()变成子表达式,一目了然,而且可以避免错误!!


    9. 所有特殊字符的纯文本形式都必须转义!

        1) 像.、^、$、\、|、[、]、{、}、(、)等特殊字符,如果想表示其纯文本形式,都必须使用\转义;

        2) 例如\(就表示纯文本的'('字符;


    10. 在Java源代码中编写正则表达式:

        1) 由于正则表达式使用的是自己的字符,而Java源代码也有自己的字符,这就会导致两者之间发生一些不可避免的冲突;

        2) 最大的冲突就是\,正则表达式中\就是一个字符(特殊字符),而Java中要表示纯文本的\也需要转义,即用\\来表示纯文本的\;

        3) 而Java源代码中编写的正则表达式对于Java源代码来说应该是纯文本,这就意味着,Java源代码中编写的正则表达式中的\都必须要用\\来表示;

        4) 例如:正则表达式\w在Java源码中编写就必须写成\\w,比较麻烦

    !小结:所有在Java源码中编写的正则表达式中的\都必须用\\表示,如果你觉得上面的原理看着头晕,那就记住这句简单的小结即可,无脑使用;

    !!即先正常写好正则表达式,然后把里面所有的\换成\\即可;

        5) 一般为了避免这种麻烦的事情,都是先在程序外部的配置文件中写好正则表达式,然后在程序中读取、编译并使用,这就避免了两者字符集的冲突了;



    展开全文
  • Java 正则表达式贪婪模式

    千次阅读 2014-07-21 17:20:44
    正则表达式的非贪婪模式。 feitanlan
  • Java 正则表达式和 Perl 的是最为相似的。 java.util.regex 包主要包括以下三个类: 1、Pattern 类: pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象,你必须首先...
  • 正则表达式基本规则与Java正则表达式使用 正则表达式匹配规则 介绍正则表达式基本匹配规则,即正则表达式字符的匹配原则以及贪婪匹配与非贪婪匹配的区别及实例。 正则表达式集及举例 字符 描述 \ 将下一个...
  • @Test public void test3(){ //参考博客:http://blog.csdn.net/gnail_oug/article/details/51260216 // 正则表达式知识详解之贪婪模式和非贪婪模式 (java版示例) //提取td元素里的内容
  • 正则表达式(regex) 贪婪模式、懒惰模式使用方法正则表达式贪婪匹配模式,对于初学者,往往也很容易出错。有时候需要匹配一个段代码内容,发现匹配与想要不一致。发现原来,跟贪婪模式有关系。如下,我们看下例子:...
  • Java 正则表达式

    万次阅读 多人点赞 2018-08-31 23:08:12
    前段时间使用Java正则表达式做一些字符串匹配的任务,现将学到的正则表达式的知识整理成文。 Java中Spring.class涉及到正则表达式。如Spring.split(), matches(),replaceAll()等方法。 Java中更一般使用正则...
  • 正则表达式贪婪与非贪婪模式 之前做程序的时候看到过正则表达式的贪婪与非贪婪模式,今天用的时候就想不起来了,现在这里总结一下,以备自己以后用到注意。 1.什么是正则表达式的贪婪与非贪婪匹配  如:...
  • Greediness(贪婪型):最大匹配X?、X*、X+、X{n,} 是最大匹配。例如你要用 “” 去匹配 “aaava abb”,也许你所期待的结果是想匹配 “”,但是实际结果却会匹配到 “aava 。在 Greediness 的模式下,会尽量大范围的...
  • 1,可使用re模块,通过正则表达式对字符串进行匹配 2,re.match函数 尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match()就返回none。 3,函数语法为:re.match(pattern, string, flags=0...
  • 利用JAVA正则表达式
  • 正则表达式贪婪与非贪婪模式 之前做程序的时候看到过正则表达式的贪婪与非贪婪模式,今天用的时候就想不起来了,现在这里总结一下,以备自己以后用到注意。 1.什么是正则表达式的贪婪与非贪婪匹配  如:...
  • 正则表达式贪婪与非贪婪模式 之前做程序的时候看到过正则表达式的贪婪与非贪婪模式,今天用的时候就想不起来了,现在这里总结一下,以备自己以后用到注意。 1.什么是正则表达式的贪婪与非贪婪匹配 如:String str=...
  • 转载自 Java 正则表达式匹配模式[贪婪型、勉强型、占有型]Greediness(贪婪型):最大匹配X?、X*、X+、X{n,} 是最大匹配。例如你要用 “&lt;.+&gt;” 去匹配 “a&lt;tr&gt;aava &lt;/tr&...
  • java正则表达式 Java正则表达式详解 http://dev.csdn.net/develop/article/83/83039.shtm java中正则表达式运用详解 http://fhd001.iteye.com/blog/410313 Java正则表达式的解释说明 ...
  • java 正则表达式

    2020-08-12 18:24:33
    java 正则表达式 1、正则表达式:regular expression搜索模式可以是简单字符,固定字符串或包含描述模式的特殊字符的复杂表达式的任何内容 由正则表达式定义的 pattern 可以同时匹配一个或多个,或者一个都没匹配到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,193
精华内容 3,277
关键字:

java正则表达式贪婪模式

java 订阅