针对“*”、“+”、“?”等限定符都是贪婪的（尽可能多的匹配字符），通过在最后追加“+”或“?”量词可改变贪婪性。本篇主要解疑正则表达式的“占有型量词”（Possessive Quantifiers）。
Greediness（贪婪型）
Pattern p = Pattern.compile("\\[.+\\]\\[.+\\]");
Matcher m = p.matcher("[che][1]'s blog is [rebey.cn][2],and built in [2016][3].");
while(m.find()) {
System.out.println(m.group());
}
// 结果：[che][1]'s blog is [rebey.cn][2],and built in [2016][3]
在不做任何额外处理情况下，正则表达式默认是贪婪型的。贪婪型一次读取所有字符进行匹配。
以下是匹配过程猜想：
“\[.+”先遍历到字符“.”时发现不匹配了，开始往左回溯，得到“[che...]”;
继续往左回溯，像这样“che...”，因此就有了以上的输出结果。
Reluctant/Laziness（勉强型）
Pattern p1 = Pattern.compile("\\[.+?\\]\\[.+?\\]");
Matcher m1 = p1.matcher("[che][1]'s blog is [rebey.cn][2],and built in [2016][3].");
while(m1.find()) {
System.out.println(m1.group());
}
// 结果：
// [che][1]
// [rebey.cn][2]
// [2016][3]
在原有的“.+”之后加个“？”，就成为了勉强型。它将从左至右依次读取进行匹配，直到字符串结束。
Possessive（占有型）
Pattern p2 = Pattern.compile("\\[.++\\]\\[.++\\]");
Matcher m2 = p2.matcher("[che][1]'s blog is [rebey.cn][2],and built in [2016][3].");
while(m2.find()) {
System.out.println(m2.group());
}
// 结果：匹配不到
在原有的“.+”之后加个“+”，就成为了占有型。它也是一次读取所有字符串进行匹配，区别在于它不回溯。
以下是匹配过程猜想：
“\[.+”匹配“[che...”直到最后字符“.”不匹配，立即结束。
x+ ≈ (?>x)
Pattern p3 = Pattern.compile("\\[.++");
Matcher m3 = p3.matcher("[che][1]'s blog is [rebey.cn][2],and built in [2016][3].");
while(m3.find()) {
System.out.println(m3.group());
}
Pattern p4 = Pattern.compile("(?>(\\[.+))");
Matcher m4 = p4.matcher("[che][1]'s blog is [rebey.cn][2],and built in [2016][3].");
while(m4.find()) {
System.out.println(m4.group());
}
结果皆为：[che][1]'s blog is [rebey.cn][2],and built in [2016][3].
注意括号。
说点什么
Possessive quantifiers are a way to prevent the regex engine from trying all permutations.
占有量词是一种用来组织正则表达式尝试所有排列组合的方式。（即不回溯）
With a possessive quantifier,the deal is all or nothing.
使用占有量词只有两种结果，全匹配或者空匹配。
The main practical benefit of possessive quantifiers is to speed up your regular expression.
占有量词的主要实际意义是加速你的正则表达式。
