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

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的返回值中
实例
下面的例子说明如何从一个给定的字符串中找到数字串：

1. (.*)正则表达式：

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?

结果分析：

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

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