Java正则表达式（Pattern、Matcher）

目录

1.常用正则标记（熟记*）

2. 基础案例搭配Sting的常用方法

3.正则表达式java.util.regex包支持

4.练习巩固

---

1.常用正则标记（熟记*）

1.字符(匹配单个字符)

字符标记	描述
a	匹配字母 "a"
\\	转义字符，用于表示特殊字符
\n	匹配换行符
\t	匹配制表符

 2.一组字符(任意匹配里面的单个字符)

正则标记	描述
[abc]	匹配字符中的任意一个，相当于 a 或 b 或 c
[^abc]	匹配除了字符中的任意一个字符之外的字符
[a-zA-Z]	匹配任意大小写字母
[0-9]	匹配任意数字字符

3.边界匹配(在以后编写JavaScript时候会用到)

正则标记	描述
^	匹配输入字符串的开始位置
$	匹配输入字符串的结束位置

4.简写标记(每一位出现的简写标记也知识表示一位)

正则标记	描述
\d	匹配一个数字字符（相当于 [0-9]）
\D	匹配一个非数字字符（相当于 [^0-9]）
\w	匹配一个单词字符（字母、数字或下划线，相当于 [a-zA-Z0-9_]）
\W	匹配一个非单词字符（相当于 [^a-zA-Z0-9_]）
\s	匹配一个空白字符（空格、制表符、换行符等）
\S	匹配一个非空白字符
.	匹配除换行符之外的任意字符

 5.数量表示（前面都表示只有一位，如果要表示多位就要用到数量表示）

正则标记	描述
?	匹配前面的元素零次或一次（可选）
*	匹配前面的元素零次或多次（可重复）
+	匹配前面的元素一次或多次（至少一次）
{n}	匹配前面的元素恰好 n 次
{n,}	匹配前面的元素至少 n 次
{n,m}	匹配前面的元素至少 n 次但不超过 m 次

6.逻辑表示与 或 非

正则标记	描述
正则表达式A	可以是任意合法的正则表达式
正则表达式B	可以是任意合法的正则表达式
正则表达式A|B	匹配正则表达式A或正则表达式B
(正则表达式)	将括号内的正则表达式作为一个组，可以对其进行量词限定等操作

---

2. 基础案例搭配Sting的常用方法

1.通过String替换（删除非字母与非数字）

package Example1516;


public class javaDemo {
    public static void main(String[] args) {
        String str= "123!#*aBC,,sd";
        String regex = "[^a-zA-Z0-9]+";
        String strs =  str.replaceAll(regex,"");
        System.out.println(strs);
    }
}

2.实现数字拆分

案例要求：一串字符串包含有数字，字母，要求只获取字母并将其存入到字符串数组中。

package Example1516;
import java.util.Arrays;

public class javaDemo {
    public static void main(String[] args) {
        String str = "a12345b165465c3516d4894";
        String regex = "\\d+";
        String strs[] = str.split(regex);
        System.out.println(Arrays.toString(strs));
    }
}

 3.判断一个数据是否为小数

package Example1516;
public class javaDemo {
    public static void main(String[] args) {
        String strs = "114514.55";
        String regex = "\\d+\\.\\d+";
        if (strs.matches(regex)){
            double d = Double.parseDouble(strs);
            System.out.println(d);
        }

    }
}

 4.判断一个字符串是否由日期组成，如果是则将其转为Date类型

package Example1516;

import java.text.SimpleDateFormat;

public class javaDemo {
    public static void main(String[] args)throws Exception {
        String dateNow = "2023-07-28";
        String regex = "\\d{4}-\\d{2}-\\d{2}";
        if (dateNow.matches(regex)){
            System.out.println("字符串为正确的日期格式");
            System.out.println(new SimpleDateFormat("yyyy-mm-dd").parse(dateNow));
        }else System.out.println("字符串并不是正确的日期格式");

    }
}

 5.验证E-mail格式：

package Example1516;

public class javaDemo {
    public static void main(String[] args) throws Exception {
        String email = "Zhangsan@qq.com";
        String regex = "[a-zA-Z0-9]+@\\w+(\\.(cn|com|com\\.cn|net|gov))";
        if (email.matches(regex)) {
            System.out.println("E-mail格式正确");
        } else {
            System.out.println("E-mail格式错误");
        }
    }
}

括号在正则表达式中用于分组，它们具有以下作用：

1. 确定匹配的范围：括号可将多个字符组合在一起，形成一个整体。例如，在 (cn|com|com\\.cn|net|gov) 中，括号内的内容表示一个选择项，即可以匹配 .cn、.com、.com.cn、.net 或 .gov。

2. 控制优先级：括号还可以控制子表达式的优先级。正则表达式按照从左到右的顺序进行解析，括号内的表达式会优先匹配。这对于复杂的正则表达式非常有用，可以确保匹配和分组的顺序符合预期。

3. 提取分组内容：通过使用括号进行分组，可以将匹配到的内容提取出来。在 Java 中，通过正则表达式匹配后，可以使用 Matcher 对象的 group(int) 方法来获取相应分组的内容。

---

3.正则表达式java.util.regex包支持

由于String类其实停供的正则表达式是比较基础的，要是严格一些则需要用到java.util,regex包的支持，该包有两个核心的功能Pattern类（正则模式）与Macther类（匹配）

以下是两个类常用的方法：

1.Pattern类

方法	描述
compile(String regex)	将给定的正则表达式编译成一个模式。
matches(String regex, CharSequence input)	使用给定的正则表达式对输入进行匹配操作，并返回匹配结果。
split(CharSequence input)	根据给定的正则表达式，将输入拆分为字符串数组，并返回结果。
matcher(CharSequence input)	创建一个新的匹配器，用于在给定的输入上执行匹配操作。
pattern()	返回当前模式的字符串表示形式。
flags()	返回模式的标志，以整数形式返回。

这些方法可以帮助你使用正则表达式进行匹配、拆分和创建匹配器等操作。其中，常用的是 matches、split 和 matcher 方法，它们为常见的正则表达式操作提供了便捷的功能。 

2.Matcher类

方法	描述
find()	尝试在输入序列中查找下一个匹配项，并返回是否找到匹配项。
group()	返回与前一次匹配操作相匹配的输入子序列。
start()	返回上次匹配操作的起始索引。
end()	返回上次匹配操作的结束索引加 1。
reset(CharSequence input)	重置匹配器，将其设置为新的输入字符序列。
replaceAll(String replacement)	使用给定的替换字符串替换所有匹配项，并返回替换后的结果。
appendReplacement(StringBuffer sb, String replacement)	将当前匹配到的内容替换为指定的字符串，并将替换结果追加到给定的 StringBuffer 对象中。
appendTail(StringBuffer sb)	将输入序列的其余部分追加到给定的 StringBuffer 对象中。

这些方法可以帮助你在使用正则表达式进行匹配操作时，获取匹配结果、替换匹配项和操作输入序列等。其中，常用的是 find、group、replaceAll 和 appendReplacement 方法，它们在实际的正则表达式处理中非常有用。 

案例使用：

1.Pattern编译

package Example1516;


import java.util.Arrays;
import java.util.regex.Pattern;

public class javaDemo {
    public static void main(String[] args) {
        String str= "123!#*aBC,,sd";
        String regex = "[^a-zA-Z0-9]+";
//        编译
        Pattern pat = Pattern.compile(regex);
//        输出
        System.out.println(Arrays.toString(pat.split(str)));
    }
}

2.Matcher

package Example1516;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class javaDemo {
    public static void main(String[] args) {
        String str= "123!#*aBC,,sd";
        String regex = "[^a-zA-Z0-9]+";

//        编译
        Pattern pat = Pattern.compile(regex);
//        匹配
        Matcher macth = pat.matcher(str);
        System.out.println(macth.matches());
//        输出
        System.out.println(Arrays.toString(pat.split(str)));
    }
}

 

3.Matcher替换

package Example1516;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class javaDemo {
    public static void main(String[] args) {
        String str= "123!#*aBC,,sd";
        String regex = "[^a-zA-Z0-9]+";

//        编译
        Pattern pat = Pattern.compile(regex);
//        匹配
        Matcher macth = pat.matcher(str);
//        matcher类函数实现
        System.out.println(macth.replaceAll(""));
        
//        输出
        System.out.println(Arrays.toString(pat.split(str)));
    }
}

 4.Matcher的分组

package Example1517;

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

public class javaDemo {
    public static void main(String[] args) {
        String str = "Insert Into dept(deptno,dname,loc) VALUES (#{deptno}#{dname}#{loc})";
        String regex = "#\\{\\w+\\}";
        Pattern pat = Pattern.compile(regex);
        Matcher mat = pat.matcher(str);
        while (mat.find()){
//去掉#{}
            String data = mat.group(0).replaceAll("#|\\{|\\}","");
            System.out.println(data);
        }
    }
}

2.

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

public class MatcherGroupExample {
    public static void main(String[] args) {
        String input = "Hello, my name is John Doe. I am 25 years old.";
        
        // 定义正则表达式模式
        Pattern pattern = Pattern.compile("(\\b\\w+\\b)\\s+(\\w+)\\s+(\\d+)\\s+years\\s+old");
        Matcher matcher = pattern.matcher(input);
        
        if (matcher.find()) {
            // 获取第一个分组中的内容
            String name = matcher.group(1);
            System.out.println("Name: " + name);
            
            // 获取第二个分组中的内容
            String surname = matcher.group(2);
            System.out.println("Surname: " + surname);
            
            // 获取第三个分组中的内容
            int age = Integer.parseInt(matcher.group(3));
            System.out.println("Age: " + age);
        }
    }
}

Name: John
Surname: Doe
Age: 25

---

4.练习巩固

给一段HTML代码"<font face="Arial,Serif" size="+2"color="red">"这段代码要求对其内容进行拆分，拆分结果如下：

face Arial,Serif

size +2

color red

思路：首先要对元素标记<font>删除，并且一句每一个属性（使用空格拆分）获取对应的数据内容，可以基于分组形式完成

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

public class HtmlCodeSplitter {
    public static void main(String[] args) {
        String htmlCode = "<font face=\"Arial,Serif\" size=\"+2\"color=\"red\">";
        
        // 定义正则表达式模式
        Pattern pattern = Pattern.compile("<font\\s+face=\"(.*?)\"\\s+size=\"(.*?)\"\\s+color=\"(.*?)\">");
        Matcher matcher = pattern.matcher(htmlCode);
        
        // 判断是否匹配成功
        if (matcher.find()) {
            String face = matcher.group(1);
            String size = matcher.group(2);
            String color = matcher.group(3);
            
            // 输出拆分结果
            System.out.println("face " + face);
            System.out.println("size " + size);
            System.out.println("color " + color);
        }
    }
}

---