Java正则表达式之Greedy、Reluctant和Possessive

12/12 编程语言 阅读 640 views 次 人气 0
摘要:

数量词
 Greedy  Reluctant  Possessive 匹配
 X? X??  X?+  X,一次或一次也没有
  X* X*?   X*+  X,零次或多次
  X+ X+?   X++  X,一次或多次
  X{n}   X{n}?  X{n}+  X,恰好 n 次
  X{n,}  X{n,}?   X{n,}+  X,至少 n 次
 X{n,m}  X{n,m}?   X{n,m}+   X,至少 n 次,但是不超过 m 次

Greedy:贪婪的;Reluctant:勉强的;Possessive :独占的。


测试1:

package jichu;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MainClass {
    public static void main(String[] args) {
        Matcher m1 = Pattern.compile("\\w+").matcher("ababa");// 贪婪的
        Matcher m2 = Pattern.compile("\\w+?").matcher("ababa");// 勉强的
        Matcher m3 = Pattern.compile("\\w++").matcher("ababa");// 独占的
        System.out.println(piPei(m1));
        System.out.println(piPei(m2));
        System.out.println(piPei(m3));
    }

    public static String piPei(Matcher m) {
        StringBuffer s = new StringBuffer();
        int i = 0;
        while (m.find()) {
            s.append("{匹配子串" + ++i + ":" + m.group() + ";");
            s.append("开始位置:" + m.start() + ";");
            s.append("结束位置:" + m.end() + ";}");
        }
        if (s.length() == 0) {
            s.append("没有匹配到!");
        }
        s.insert(0, "(模式" + m.pattern().pattern() + "):");
        return s.toString();
    }
}

打印:

(模式\w+):{匹配子串1:ababa;开始位置:0;结束位置:5;}
(模式\w+?):{匹配子串1:a;开始位置:0;结束位置:1;}{匹配子串2:b;开始位置:1;结束位置:2;}{匹配子串3:a;开始位置:2;结束位置:3;}{匹配子串4:b;开始位置:3;结束位置:4;}{匹配子串5:a;开始位置:4;结束位置:5;}
(模式\w++):{匹配子串1:ababa;开始位置:0;结束位置:5;}

从测试1中可知:

1、对于贪婪的,会一次性匹配所有的字符;

2、对于勉强的,会从左到右一个一个的匹配;

3、对于独占的,与贪婪的一样也是一次性匹配所有的字符;

测试2:(在测试1的基础上修改main方法)

    public static void main(String[] args) {
        Matcher m1 = Pattern.compile("\\w+b").matcher("ababa");// 贪婪的
        Matcher m2 = Pattern.compile("\\w+?b").matcher("ababa");// 勉强的
        Matcher m3 = Pattern.compile("\\w++b").matcher("ababa");// 独占的
        System.out.println(piPei(m1));
        System.out.println(piPei(m2));
        System.out.println(piPei(m3));
    }

打印:

(模式\w+b):{匹配子串1:abab;开始位置:0;结束位置:4;}
(模式\w+?b):{匹配子串1:ab;开始位置:0;结束位置:2;}{匹配子串2:ab;开始位置:2;结束位置:4;}
(模式\w++b):没有匹配到!

从测试1、2中可知:

1、对于贪婪的,'\w+'已经一次性匹配了所有的字符;当模式后加'b'后,此时不匹配,然后回溯1个字符,匹配成功。

2、对于勉强的,从左到右匹配,匹配出两个子串。

3、对于独占的,'\w++'已经一次性匹配了所有的字符;当模式后加'b'后,此时不匹配,与贪婪的不一样的是它不会回溯,所以匹配失败。


总结

1、Greedy数量词为“贪婪的”,如名字一样,多吃多占,它会尽可能多的匹配字符,会回溯。

2、Reluctant数量词为“勉强的”,奉行够用主义,它会尽可能少的匹配字符。

3、Possessive数量词为“独占的”,它会如Greedy一样尽可能多的匹配字符,但是它不会回溯。

评论

该文章不支持评论!

分享到: