[正则表达式]正则表达式(.*)和(.*?)的字符串匹配问题

Java 正则表达式

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

Java正则表达式和Perl的是最为相似的。

java.util.regex包主要包括以下三个类：

Pattern类：

pattern对象是一个正则表达式的编译表示。Pattern类没有公共构造方法。要创建一个Pattern对象，你必须首先调用其公共静态编译方法，它返回一个Pattern对象。该方法接受一个正则表达式作为它的第一个参数。

Matcher类：

Matcher对象是对输入字符串进行解释和匹配操作的引擎。与Pattern类一样，Matcher也没有公共构造方法。你需要调用Pattern对象的matcher方法来获得一个Matcher对象。

PatternSyntaxException：

PatternSyntaxException是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

捕获组

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

例如，正则表达式(dog) 创建了单一分组，组里包含”d”，”o”，和”g”。

捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：

1. ((A)(B(C)))

2. (A)

3. (B(C))

4. (C)

可以通过调用matcher对象的groupCount方法来查看表达式有多少个分组。groupCount方法返回一个int值，表示matcher对象当前有多个捕获组。

还有一个特殊的组（组0），它总是代表整个表达式。该组不包括在groupCount的返回值中

实例

下面的例子说明如何从一个给定的字符串中找到数字串：

(.*)正则表达式：

String regular = "(.*)(\\d+)(.*)";
//第一个分组是(.*),第二个分组是(\\d+)，第三个分组是(.*)

package com.clfeng.regularExpression;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

public static void main(String[] args) {
// 按制定模式在字符串中查找
String line = "This order was placed for QT3000! OK?";
String regular = "(.*)(\\d+)(.*)";

// 创建pattern对象
Pattern pattern = Pattern.compile(regular);

// 创建matcher对象
Matcher matcher = pattern.matcher(line);

if (matcher.find()) {
System.out.println("Found value:" + matcher.group(0));
System.out.println("Found value:" + matcher.group(1));
System.out.println("Found value:" + matcher.group(2));
System.out.println("Found value:" + matcher.group(3));
}
}
}

运行结果

Found value:This order was placed for QT3000! OK?

Found value:This order was placed for QT300

Found value:0

Found value:! OK?

2 (.*?)正则表达式

String regular = "(.*?)(\\d+)(.*)";
//第一个分组是(.*?),第二个分组是(\\d+)，第三个分组是(.*)

package com.clfeng.regularExpression;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

public static void main(String[] args) {
// 按制定模式在字符串中查找
String line = "This order was placed for QT3000! OK?";
String regular = "(.*?)(\\d+)(.*)";

// 创建pattern对象
Pattern pattern = Pattern.compile(regular);

// 创建matcher对象
Matcher matcher = pattern.matcher(line);

if (matcher.find()) {
System.out.println("Found value:" + matcher.group(0));
System.out.println("Found value:" + matcher.group(1));
System.out.println("Found value:" + matcher.group(2));
System.out.println("Found value:" + matcher.group(3));
}
}
}

运行结果

Found value:This order was placed for QT3000! OK?

Found value:This order was placed for QT

Found value:3000

Found value:! OK?

结果分析：

(.*)正则表达式

(.*)涉及到贪婪模式。当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。以这个表达式为例：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。所以第一个程序第一个分组匹配的的结果是Found value:This order was placed for QT300，尽可能匹配多的字符（因为第二组还要匹配数字，所以匹配到300）

(.*?)正则表达式

有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。a.?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。所以第二个程序的第一个分组匹配的的结果是Found value:This order was placed for QT，匹配尽可能少的字符（因为第二组还要匹配数字，所以匹配到QT）。