查看“正则表达式元字符限定符”的源代码

https://www.bilibili.com/video/BV1Eq4y1E79W?p=11

限定符用于指定其前面的字符和组合项连续出现多少次
{| class="wikitable"
!符号
!含义
!示例
!说明
!匹配输入
|-
|*
|指定字符重复0次或n次（无要求）
|(abc)*
|仅包含任意个abc的字符串，等效于 \w*
|abc、abcabcabc
|-
| +
|指定字符重复1次或n次（至少1次）
|m+(abc)*
|以至少1个m开头，后接任意个abc的字符串
|m、mabc、mabcabc
|-
|?
|指定字符重复0次或1次（最多1次）
|m+abc?
注意：abc没有用括号括起来，?就只会作用在离它最近的字符 c 
|以至少1个m开头，后接ab或abc的字符串
|mab、mabc、mmmab、mmabc
|-
|{n}
|只能输入n个字符
|[abcd]{3}
|由abcd中字母组成的任意长度为3的字符串
|abc、dbc、adc
|-
|{n,}
|指定至少 n 个匹配
|[abcd]{3,}
|由abcd中字母组成的任意长度不小于3的字符串
|aab、dbc、aaadbc
|-
|{n,m}
|指定至少n个但不多于m个匹配
|[abcd]{3,5}
|由abcd中字母组成的任意长度不小于3，不大于5的字符串
|abc、abcd、aaaaa、bcdab
|}
注意：贪婪匹配的原则，表达式会尽可能匹配更多的字符

=== 关于限定符 "+" 加号的测试示例 ===
<syntaxhighlight lang="java">
public class PlusSymbioTest {

    public static void main(String[] args) {

        PlusSymbioTest test = new PlusSymbioTest();

        test.test1();

        test.test2();

        test.test3();

    }

    public void test1() {

        String content = "abab";

        String regex = "ab+";

        System.out.println(content.matches(regex));

    }

    public void test2() {

        String content = "abb";

        String regex = "ab+";

        System.out.println(content.matches(regex));

    }

    public void test3() {

        String content = "abab";

        String regex = "(ab)+";

        System.out.println(content.matches(regex));

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
false
true
true
</syntaxhighlight>'''<big>结论：所以默认没有圆括号的情况下限定符应该是只和前面的一个字结合，加括号才代表多个字符连接在一起的子式作为限定符生效的对象。</big>'''


=== 示例1：在 "1111111" 中找 a{3} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "1111111";

        String regStr = "a{3}"; //表示匹配 3 个连续的字符a，等价与 aaa

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight>因为没有对应的内容，所以控制台什么都不输出





=== 示例2：在 "1111111aaahello" 中找 a{3} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "1111111aaahello";

        String regStr = "a{3}"; //表示匹配 3 个连续的字符a，等价与 aaa

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：aaa
</syntaxhighlight>


=== 示例3：在 "1111111aaahello" 中找 1{4} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "1111111aaahello";

        String regStr = "1{4}"; //表示匹配 4 个连续的字符1，等价与 1111

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：1111
</syntaxhighlight>




=== 示例4：在 "1111111aaahello" 中找 \\d{2} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "1111111aaahello";

        String regStr = "\\d{2}"; //表示匹配 2 个连续的数字字符，等价于 [0-9]{2}

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：11
找到：11
找到：11
</syntaxhighlight>




=== 示例5：在 "1111111aaaahello" 中找 a{3,4} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "1111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "a{3,4}"; //表示匹配 3-4 个连续的字符 a， aaa 或 aaaa，优先匹配 4 个连续的字符 a

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：aaaa

</syntaxhighlight>'''<big>注意：默认是贪婪匹配，尽可能匹配更多的字符，匹配出更长的字符串</big>'''




=== 示例6：在 "1111111aaaahello" 中找 1{4,5} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "1111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "1{4,5}"; //表示匹配 4-5 个连续的字符 1， 1111 或 11111，优先匹配 5 个连续的字符 1

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：11111

</syntaxhighlight>




=== 示例7：在 "1111111aaaahello" 中找 \\d{2,5} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "1111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "\\d{2,5}"; //表示匹配 2-5 个连续的数字字符，优先匹配 5 个连续的数字字符

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：11111
找到：11
</syntaxhighlight>'''<big>注意：贪婪匹配</big>'''







=== 示例8：在 "111111aaaahello" 中找 \\d{2,5} ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "\\d{2,5}"; //表示匹配 2-5 个连续的数字字符，优先匹配 5 个连续的数字字符

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：11111

</syntaxhighlight>




=== 示例9：在 "111111aaaahello" 中找 1+ ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "1+"; //表示匹配1个或连续的多个数字字符 1

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：111111

</syntaxhighlight>




=== 示例10：在 "111111aaaahello" 中找 \\d+ ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "\\d+"; //表示匹配1个或连续的多个数字字符 相当于[0-9]{1,}、[0-9]+

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：111111
</syntaxhighlight>




=== 示例11：在 "111111aaaahello" 中找 1* ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "1*"; //表示匹配0个或连续的多个数字字符 1

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：111111
找到：
找到：
找到：
找到：
找到：
找到：
找到：
找到：
找到：
找到：
</syntaxhighlight>




=== 示例12：在 "a111111aaaahello" 中找 a1? ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "a111111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "a1?"; //表示匹配 单个字符 a 或 a1, ?表示出现0次或1次，最多1次

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}

</syntaxhighlight><syntaxhighlight lang="console">
找到：a1
找到：a
找到：a
找到：a
找到：a
</syntaxhighlight>


=== 示例13：在 "a211111aaaahello" 中找 a1? ===
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp05 {

    public static void main(String[] args) {

        String content = "a211111aaaahello";

        //默认是贪婪匹配，尽可能匹配多的
        String regStr = "a1?"; //表示匹配 单个字符 a 或 a1, ?表示出现0次或1次，最多1次

        Pattern pattern = Pattern.compile(regStr);

        Matcher matcher = pattern.matcher(content);

        while (matcher.find()) {
            System.out.println("找到："+ matcher.group(0));
        }

    }

}
</syntaxhighlight><syntaxhighlight lang="console">
找到：a
找到：a
找到：a
找到：a
找到：a
</syntaxhighlight>