正则表达式—Qulifiers

Qulifiers(修饰符、限定符)
 
aaaa5bbbb6
 

Greedy默认使用

 
默认使用 Greedy：(.{3,10})[0-9]
 
Greedy 和 Reluctant的区别
 
Greedy的意思是说：当它看到这个正则表达式以后 .{3,10}，最多10个字符，那么它就二话不说先吞进去10个字符再说，吞进10个字符之后，在和整个正则表达式 (.{3,10})[0-9] 做匹配 ，匹配不上，因为最后吞进去10个字符，只匹配了前面的半截正则表达式 (.{3,10})，[0-9]最后面的字母没有，它一看不行就往外吐一个(吐出 6)，吐出的这一个作为后面这半截这个数字的话，前面半截正则表达式和前面9位字符匹配，整个正则表达式就可以匹配了。
 
Greedy：它不是挑最少的吞它是挑最大的吞

// Qulifiers(修饰符、限定符)
// 默认使用 Greedy：(.{3,10})[0-9]
// Greedy的意思是说：当它看到这个正则表达式以后  .{3,10}，最多10个字符，
// 那么它就二话不说先吞进去10个字符再说，吞进10个字符之后，
// 在和整个正则表达式 (.{3,10})[0-9] 做匹配 ，匹配不上，
// 因为最后吞进去10个字符，只匹配了前面的半截正则表达式 (.{3,10})，
// [0-9]最后面的字母没有，它一看不行就往外吐一个(吐出 6)，
// 吐出的这一个作为后面这半截这个数字的话，前面半截正则表达式和前面9位字符匹配，
// 整个正则表达式就可以匹配了。

// Greedy：它不是挑最少的吞它是挑最大的吞

public class Test9_1 {

	public static void main(String[] args) {
		// Qulifiers
		// Greedy：它不是挑最少的吞它是挑最大的吞
		// (.{3,10})：3到10个字符
		// [0-9]：后面跟着1位数字
		Pattern p = Pattern.compile("(.{3,10})[0-9]");
		String s = "aaaa5bbbb6";
		Matcher m = p.matcher(s);
		// 输出的结果为 0-10
		// 实际就是整个字符串为子串
		if (m.find())
			p(m.start() + "-" + m.end());
		else
			p("not match!");
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

Reluctant

 
Reluctant：(.{3,10}?)[0-9]
 
Reluctant：它不是挑最多的吞它是挑最少的吞
 
先吃进来 3个，吃进来 3 个(aaa)之后，在看看后面的字符(第4个a)是后半截正则表达式里的吗[0-9]，不是数字所以在吞一个，吞一个之后后面是一个数字吗，5是数字了，所以到此结束了

// Qulifiers(修饰符、限定符)

// Reluctant：(.{3,10}?)[0-9]
// Reluctant：它不是挑最多的吞它是挑最少的吞
// 先吃进来 3个，吃进来 3 个(aaa)之后，
// 在看看后面的字符(第4个a)是后半截正则表达式里的吗[0-9]，
// 不是数字所以在吞一个，吞一个之后后面是一个数字吗，5是数字了，所以到此结束了

public class Test9_2 {

	public static void main(String[] args) {

		// Reluctant加?
		// Reluctant：它不是挑最多的吞它是挑最少的吞
		Pattern p = Pattern.compile("(.{3,10}?)[0-9]");
		String s = "aaaa5bbbb6";
		Matcher m = p.matcher(s);
		// 输出的结果为 0-10
		// 实际就是整个字符串为子串
		if (m.find())
			p(m.start() + "-" + m.end());
		else
			p("not match!");
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}

Possessive(用的比较少)

 
Possessive(用的比较少)：独占的 和Greedy有相似的，它就直接把最大的10个字符吞进来，然后它不吐，它不会往外吐来进行正则表达式的匹配，最后一位没有 ( [0-9] 后面的半截正则表达式没有匹配的)，因此匹配不上
 

Possessive它一下就吞进去10个( aaaa5bbbb6 )，吞进去10个字后，最后一位( [0-9] )没有和它匹配的了,它就连吐都不吐，然后说明找不到然后就退出了(最求效率的时候可以使用这个)

// Qulifiers(修饰符、限定符)
// Possessive(用的比较少)：独占的 和Greedy有相似的，
// 它就直接把最大的10个字符吞进来，然后它不吐，
// 它不会往外吐来进行正则表达式的匹配，
// 最后一位没有 ( [0-9] 后面的半截正则表达式没有匹配的)，因此匹配不上

public class Test9_3 {

	public static void main(String[] args) {

		// Possessive它一下就吞进去10个( aaaa5bbbb6 )，
		// 吞进去10个字后，最后一位( [0-9] )没有和它匹配的了,
		// 它就连吐都不吐，然后说明找不到然后就退出了(最求效率的时候可以使用这个)
		Pattern p = Pattern.compile("(.{3,10}+)[0-9]");
		String s = "aaaa5bbbb6";
		Matcher m = p.matcher(s);
		// 输出的结果为 0-10
		// 实际就是整个字符串为子串
		if (m.find())
			p(m.start() + "-" + m.end());
		else
			p("not match!");
	}

	public static void p(Object o) {
		System.out.println(o);
	}
}