正则表达式三种数量词  

Greedy 数量词   (贪婪的)!【每次取最多，不成，往出吐个，再试】! 
X?    X，一次或一次也没有 
X*    X，零次或多次X+X，一次或多次 
X{n}    X，恰好 n 次 
X{n,}    X，至少 n 次 
X{n,m}    X，至少 n 次，但是不超过 m 次 
Reluctant 数量词   （不情愿的，勉强的）!【每次取最少，不成，吸入一个，再试】! 
X??    X，一次或一次也没有 
X*?    X，零次或多次 
X+?    X，一次或多次 
X{n}?    X，恰好 n 次X 
{n,}?    X，至少 n 次 
X{n,m}?    X，至少 n 次，但是不超过 m 次 
Possessive 数量词   （独占的）  !【每次取最多，不吐】! 
X?+    X，一次或一次也没有 
X*+    X，零次或多次 
X++    X，一次或多次 
X{n}+    X，恰好 n 次 
X{n,}+    X，至少 n 次 
X{n,m}+    X，至少 n 次，但是不超过 m 次

1 Matcher m=Pattern.compile("a.*b")
2               .matcher("a====b=========b=====");
3 while(m.find()){
4       System.out.println(m.group());
5         }
6 
7 
8 输出：
9 a====b=========b

因为总是从最大 匹配开始匹配，故称贪婪。

Reluctant正好和Greedy相反，它先从最小匹配开始，先从左端吞入一个字符，然后进行匹配，若不匹配就再吞入一个字符，直到找到匹配或将整个字符串吞入为止。

1 Matcher m=Pattern.compile("a.*?b")
2                   .matcher("a====b=========b=====");
3 while(m.find()){
4         System.out.println(m.group());
5         }
6 
7 输出：
8 a====b

Possessive和Greedy的匹配方式一样，先把整个字符串吞下，然后匹配整个字符串，如果匹配，就认为匹配，如果不匹配，就认为整个字符串不匹配，它不会从右端吐出一个字符串再进行匹配，只进行一次

1 Matcher m=Pattern.compile("a.*+b")
2                    .matcher("a====b=========b=====");
3 while(m.find()){
4     System.out.println(m.group());
5         }
6 
7 输出：
8 （无输出）

*******************
我的理解是

String text = "a====b=========b";

String reg = "a.*+b";

由于.代表任意字符，字母b和=都算匹配到了模式中（.*+），最后 "a.*+b"中的b没有找到匹配字符，所以不匹配。

如果这样：

String text = "a54564b";

String reg = "a\\d*+b";

"a54564b"中字母b不能吸收进“\\d*+”，最后匹配结果是true。