正则表达式(.*?)

先看一下，下面是C#实现提取小括号内的内容的示例代码

                string str = "aaaaaaaaa(bbbbbb) 121 (fdsa) 121(aa)2121jlkoihj";
                string pattern = @"(.*?)";//匹配模式
                Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
                MatchCollection matches = regex.Matches(str);
                StringBuilder sb = new StringBuilder();//存放匹配结果
                foreach (Match match in matches)
                {
                    string value = match.Value;
                    sb.AppendLine(value);
                }

返回的结果是：

(bbbbbb)
(fdsa)
(aa)

下面是辅助资料

从网上搜的，留下来认真地再看一下

1、. 匹配任意除换行符“ ”外的字符；
2、*表示匹配前一个字符0次或无限次；
3、+或*后跟？表示非贪婪匹配，即尽可能少的匹配，如*？重复任意次，但尽可能少重复；
4、 .*? 表示匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。如：a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab和ab。

下面是主详细解释

1. .*
. 表示 匹配除换行符 之外的任何单字符，*表示零次或多次。所以.*在一起就表示任意字符出现零次或多次。没有?表示贪婪模式。比如a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。
又比如模式src=`.*`， 它将会匹配最长的以 src=` 开始，以`结束的最长的字符串。用它来搜索 <img src=``test.jpg` width=`60px` height=`80px`/> 时，将会返回 src=``test.jpg` width=`60px` height=`80px`

2. .*?
?跟在*或者+后边用时，表示懒惰模式。也称非贪婪模式。就是匹配尽可能少的字符。就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。
a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。
又比如模式 src=`.*?`，它将会匹配 src=` 开始，以 ` 结束的尽可能短的字符串。且开始和结束中间可以没有字符，因为*表示零到多个。用它来搜索 <img src=``test.jpg` width=`60px` height=`80px`/> 时，将会返回 src=``。

3. .+?
同上，?跟在*或者+后边用时，表示懒惰模式。也称非贪婪模式。就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。
a.+?b匹配最短的，以a开始，以b结束的字符串，但a和b中间至少要有一个字符。如果把它应用于ababccaab的话，它会匹配abab（第一到第四个字符）和aab（第七到第九个字符）。注意此时匹配结果不是ab,ab和aab。因为a和b中间至少要有一个字符。
又比如模式 src=`.+?`，它将会匹配 src=` 开始，以 ` 结束的尽可能短的字符串。且开始和结束中间必须有字符，因为+表示1到多个。用它来搜索 <img src=``test.jpg` width=`60px` height=`80px`/> 时，将会返回 src=``test.jpg`。注意与.*?时的区别，此时不会匹配src=``，因为src=` 和 ` 之间至少有一个字符。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;

public class TestRegx {

  @Test
  public void testRegx(){

    String str = "<img src=``test.jpg` width=`60px` height=`80px`/>";

    String pattern1 = "src=`.*`";
    String pattern2 = "src=`.*?`";
    String pattern3 = "src=`.+?`";

    Pattern p1 = Pattern.compile(pattern1);
    Pattern p2 = Pattern.compile(pattern2);
    Pattern p3 = Pattern.compile(pattern3);

    Matcher m1 = p1.matcher(str);
    Matcher m2 = p2.matcher(str);
    Matcher m3 = p3.matcher(str);

    System.out.println("根据pattern1匹配的结果：");
    if (m1.find()) {
      for(int i=0; i<=m1.groupCount(); i++){
        System.out.println(m1.group(i));
      }
    }

    System.out.println("根据pattern2匹配的结果：");
    if (m2.find()) {
      for(int i=0; i<=m2.groupCount(); i++){
        System.out.println(m2.group(i));
      }
    }

    System.out.println("根据pattern3匹配的结果：");
    if (m3.find()) {
      for(int i=0; i<=m3.groupCount(); i++){
        System.out.println(m3.group(i));
      }
    }

    String[] str1 = p1.split(str);
    String[] str2 = p2.split(str);
    String[] str3 = p3.split(str);

    System.out.println("根据pattern1切分的结果");
    for (int i=0; i< str1.length; i++) {
      System.out.println(str1[i]);
    }

    System.out.println("根据pattern2切分的结果");
    for (int i=0; i< str2.length; i++) {
      System.out.println(str2[i]);
    }

    System.out.println("根据pattern3切分的结果");
    for (int i=0; i< str3.length; i++) {
      System.out.println(str3[i]);
    }
  }
}