一、数量词:Greedy Reluctant Possessive                

        String str = "abcdabg";				// ①Greedy		// output:abcdab 		Pattern pattern1 = Pattern.compile(".*ab");		Matcher matcher1 = pattern1.matcher(str);		while (matcher1.find()) {			System.out.print(matcher1.group() + " ");		}		System.out.println();				// ②Reluctant		// output:ab cdab 		Pattern pattern2 = Pattern.compile(".*?ab");		Matcher matcher2 = pattern2.matcher(str);		while (matcher2.find()) {			System.out.print(matcher2.group() + " ");		}		System.out.println();				// ③Possessive 		// no output		Pattern pattern3 = Pattern.compile(".*+ab");		Matcher matcher3 = pattern3.matcher(str);		while (matcher3.find()) {			System.out.println(matcher3.group());		}

1.Greedy：贪婪，表示匹配的时候先匹配整个字符串，如果匹配成功，则终止，如果不匹配，再从右向左一个一个吐出来（因为他太贪婪了），过程如下：

模式：.*ab，要匹配的字符abcdabg，注意是.*来匹配

1.先匹配abcdabg，不成功

2.匹配abcdab，还是不成功

3.匹配abcda，还是不成功

4.匹配abcd，匹配成功,后面刚好是ab

所以最终输出的是abcdab

2.Reluctant 勉强,匹配过程是从左到右,先从最左边吃掉一个字符,不匹配的话接着吃点(我很不愿意,所以很勉强),一直到匹配的,但这时不会退出,而是继续匹配,过程如下:

模式：.*?ab，要匹配的字符abcdabg，注意是.*来匹配

1.先匹配a，不成功

2.匹配ab，成功,继续匹配

3.匹配c，不成功

4.匹配cd，成功,后面刚好是ab

5.匹配cda，不成功,继续匹配到末尾

所以最终输出的是ab cdab

3.Possessive 侵占,表示我一次性匹配整个字符串,而且只匹配一次,要么成功,要么不成功 

模式：.*+ab，要匹配的字符abcdabg，注意是.*来匹配

1.直接匹配abcdabg,.*直接吃掉整个字符串了,没有字符来匹配后面的ab了,当然是不匹配了,然后就终止了,所以没有任何输出

二、捕获与非捕获

这2个都是用()来包起来的，看下面的例子就知道2者的区别了

String str = "industries";  // ①捕获 Pattern pattern1 = Pattern.compile("industr(y|ies)"); Matcher matcher1 = pattern1.matcher(str); while (matcher1.find()) { System.out.println(matcher1.group(0) + "+++" + matcher1.group(1)); }  // ②非捕获 Pattern pattern2 = Pattern.compile("industr(?:y|ies)"); Matcher matcher2 = pattern2.matcher(str);  while (matcher2.find()) { System.out.println(matcher1.group(0) + "+++" + matcher2.group(1)); }

结果为：

industries+++iesException in thread "main" java.lang.IllegalStateException: No match found at java.util.regex.Matcher.group(Matcher.java:468) at com.reg.TestAt.main(TestAt.java:47)

对于捕获的,()会被当做一个分组,所以还有一个小标为1的组

但是对于非捕获,是没有组的,所以就出现下标异常了

三、非捕获

直接看下面的例子比较容易理解:

System.out.println("---------(?=X)---------");		// lookahead 向后看		// (?=X) X，通过零宽度的正 lookahead 		/*表达式"a(?=b)c"不能匹配"abc"，也不能匹配"ac"、"ab"。而且不能匹配任何字符串。因为其预测匹配a的位置后，应该是b，但是，又要求a之后是c。		表达式"a(?=b)bc"是可以匹配"abc"的，但是不能匹配"ab"和"ac"。*/		Pattern p1 = Pattern.compile("a(?=c)");		System.out.println(p1.matcher("ac").matches());// 这种是不包含的,所以为false,对比下面的		Matcher matcher1 = p1.matcher("ac");		while(matcher1.find()) {			System.out.println(matcher1.group());// 结果为a		}				System.out.println("---------(?>X)---------");		Pattern p11 = Pattern.compile("a(?>c)");		System.out.println(p11.matcher("ac").matches());// 这种是包含的,所以为true,对比上面的		Matcher matcher11 = p11.matcher("ac");		while(matcher11.find()) {			System.out.println(matcher11.group());		}				System.out.println("---------(?!X)---------");		// (?!X) X，通过零宽度的负 lookahead 		// a(?!c)b 表示a后面不能是c,且是b,所以为true		Pattern p2 = Pattern.compile("a(?!c)b");// a(?!b)b		System.out.println(p2.matcher("ab").matches());				System.out.println("---------(?<=X)---------");		// lookbehind 向前看		// (?<=X) X，通过零宽度的正 lookbehind 		// a(?<=a)c 表示c前面必须是a		Pattern p3 = Pattern.compile("a(?<=a)c");		System.out.println(p3.matcher("ac").matches());				System.out.println("---------(?
    X) X，作为独立的非捕获组 		// 指针会移动(是包含在内的),注意和(?=X)的区别		Pattern p5 = Pattern.compile("a(?:b)"); 		System.out.println(p5.matcher("ab").matches());		Pattern p9 = Pattern.compile("a(?>b)");		System.out.println(p9.matcher("ab").matches());

上面例子都理解了,非捕获基本也就理解了,不过实际中用的也不多