摘要：
X{n，m}+X，至少n倍，但不超过m倍贪婪：贪婪；勉强的：勉强的；占有：独占。测试1：软件包ABCD；importjava.util.regex.Matcher；importjava.util.regex.Pattern；PublicclassMainClass｛publicstaticvoidmain｛Matcherm1=Pattern.compile.matcher；//Greedy Matcherm2=Pattern.cocompile（“w+？”）.matcher。//不情愿Matcherm3=Pattern.compile.maatcher；//Exclusive System.out.println；System.out.prprintln；｝publicstaticStringpiPei｛StringBuffers=newStringBuffer（）；ini=0；而｛s.append；s.append“不匹配！更多与正则表达式相关的内容：java正则规则表、java模式类、java匹配器类、java
| 数量词 | |||
| 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：
packagejichu; importjava.util.regex.Matcher; importjava.util.regex.Pattern; public classMainClass { public static voidmain(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 staticString piPei(Matcher m) { StringBuffer s = newStringBuffer(); 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() + "）："); returns.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 voidmain(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一样尽可能多的匹配字符，但是它不会回溯。
更多与正则表达式相关内容：