简单了解正则表达式

概要

正则表达式（Regular Expression）是一种强大的文本模式匹配工具，在很多编程语言中都被广泛应用，包括 Java、Python、JavaScript 等。

主要作用

文本匹配：可以用来查找特定模式的文本。例如，从一大段文本中找出所有的电子 邮箱地址、电话号码等。
文本验证：验证输入的文本是否符合特定的格式要求。比如验证用户输入的密码是否符合复杂度要求、验证网址是否合法等。
文本替换：可以根据特定的模式对文本进行替换操作。比如将文本中的所有数字替换为特定的字符。
文本分割：根据特定的模式将文本分割成多个部分。例如以逗号或空格为分隔符分割字符串。

基本语法

字符类：
[abc]：匹配 a、b 或 c 中的任意一个字符。
[a-z]：匹配小写字母 a 到 z 中的任意一个字符。
[^abc]：匹配除了 a、b、c 之外的任意一个字符。
量词：
*：匹配前面的字符零次或多次。
+：匹配前面的字符一次或多次。
?：匹配前面的字符零次或一次。
{n}：匹配前面的字符恰好 n 次。
{n,}：匹配前面的字符至少 n 次。
{n,m}：匹配前面的字符至少 n 次，至多 m 次。
特殊字符：
.：匹配任意一个字符，除了换行符。
\d：匹配一个数字字符，相当于[0-9]。
\D：匹配一个非数字字符，相当于[^0-9]。
\w：匹配一个单词字符，包括字母、数字和下划线，相当于[a-zA-Z0-9_]。
\W：匹配一个非单词字符，相当于[^a-zA-Z0-9_]。
\s：匹配一个空白字符，包括空格、制表符、换行符等。
\S：匹配一个非空白字符。
边界匹配：
^：匹配输入字符串的开始位置。
$：匹配输入字符串的结束位置。

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

public class RegexExample {
    public static void main(String[] args) {
        // 验证电子邮箱格式
        String email = "test@example.com";
        String emailRegex = "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$";
        Pattern pattern = Pattern.compile(emailRegex);
        Matcher matcher = pattern.matcher(email);
        if (matcher.matches()) {
            System.out.println("Email is valid.");
        } else {
            System.out.println("Email is invalid.");
        }

        // 提取文本中的数字
        String text = "There are 123 apples and 456 oranges.";
        String numberRegex = "\\d+";
        pattern = Pattern.compile(numberRegex);
        matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("Found number: " + matcher.group());
        }
    }
}

量词

在正则表达式中，量词用于指定一个模式出现的次数。以下是一些量词的用法示例：

一、“”（零次或多次）
匹配前面的字符零次或多次。
例如，正则表达式a可以匹配字符串""（空字符串，因为a出现了零次）、“a”（a出现了一次）、“aa”（a出现了两次）等。

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

public class RegexQuantifierExample {
    public static void main(String[] args) {
        String text = "aaaaa";
        String regex = "a*";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("Matched: " + matcher.group());
        }
    }
}

二、“+”（一次或多次）
匹配前面的字符一次或多次。
例如，正则表达式a+可以匹配字符串"a"、“aa”、"aaa"等，但不能匹配空字符串。

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

public class RegexQuantifierExample2 {
    public static void main(String[] args) {
        String text = "aaaaa";
        String regex = "a+";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("Matched: " + matcher.group());
        }
    }
}

三、“?”（零次或一次）
匹配前面的字符零次或一次。
例如，正则表达式a?可以匹配字符串"“（a出现了零次）和"a”（a出现了一次）。

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

public class RegexQuantifierExample3 {
    public static void main(String[] args) {
        String text = "a";
        String regex = "a?";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("Matched: " + matcher.group());
        }
    }
}

四、“{n}”（恰好 n 次）
匹配前面的字符恰好 n 次。
例如，正则表达式a{3}可以匹配字符串"aaa"。

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

public class RegexQuantifierExample4 {
    public static void main(String[] args) {
        String text = "aaa";
        String regex = "a{3}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("Matched: " + matcher.group());
        }
    }
}

五、“{n,}”（至少 n 次）
匹配前面的字符至少 n 次。
例如，正则表达式a{2,}可以匹配字符串"aa"、“aaa”、"aaaa"等。

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

public class RegexQuantifierExample5 {
    public static void main(String[] args) {
        String text = "aaaa";
        String regex = "a{2,}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("Matched: " + matcher.group());
        }
    }
}

六、“{n,m}”（至少 n 次，至多 m 次）
匹配前面的字符至少 n 次，至多 m 次。
例如，正则表达式a{2,4}可以匹配字符串"aa"、“aaa”、“aaaa”，但不能匹配"a"或"aaaaa"等。

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

public class RegexQuantifierExample6 {
    public static void main(String[] args) {
        String text = "aaa";
        String regex = "a{2,4}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            System.out.println("Matched: " + matcher.group());
        }
    }
}