Java 正则表达式

正则表达式是一个用于匹配字符串的模板，用于匹配字符串。

正则表达式语法：

.　　小数点，可匹配\n之外的任何一个字符，要匹配小数点，用.

x　　x是某一具体字符，表示匹配该字符

\d　　匹配0-9之间的一个数字

\D　　匹配\d之外的任一个字符

\s　　匹配任一个空白，包括空格、制表符、回车符、换行符

\S　　匹配\s之外的任一个字符

\w　　匹配任一个单词字符，包括数字0-9，英文字母大写26个、小写26个，下划线_

\W　　匹配\w之外的任一个字符

\t　　制表符

\n　　换行符

\r　　回车符

以上式子均只匹配一个字符

\　　表示匹配一个正则表达式中的预定义符号，例：\匹配一个\， (匹配一个（， ?匹配一个？

|　　表示2项中选择一项，相当于“或”。例：ab|c表示匹配ac或bc，（ab)|[a-d]表示匹配ab或a-d之间的任一个字符，ab|cd|e表示匹配abd、abe、acd、ace中的任一个。

() 表示一个子表达式，将此子表达式作为一个整体来看。要匹配（），用( )

中括号：

[]　　表示匹配指定范围中的任一个字符，例：[abc]表示匹配a、b、c中的任一个字符。

-　　表示范围，例：[!a-z]表示匹配!、所有小写字母中的任一个字符

^　　表示非，例：[^{abc]表示匹配a、b、c之外的任一个字符，[}a-d]表示匹配a、b、c、d之外的任一个字符。要把后面部分当成一个整体来看

&&　　表示取交集，例：[a-d&&c-z]相当于[cd]，匹配c，d中的任一个字符

中括号只匹配一个字符。要匹配[] ，使用[　　]

数量限定：

*　　0次及以上。匹配*请用*

+　　1次及以上。匹配+请用+

?　　0次或1次

{m} m次

{m,}　　至少m次

{m,n}　　至少m次，至多n次。

以上均表示前一个字符、（子）表达式出现的次数

位置限定：

^　　行的开头，放在该部分前面，例：^H 表示匹配H，H要是一行的开头

$行的结尾，放在该部分的后面，例：。$ 表示匹配。 。要是一行的结尾

\b　　单词的边界，前边界就放在该部分的前面，后边界就放在该部分的后面，例：\bH 表示匹配H，H要是某个单词的开头；H\b表示匹配H，H要是某个单词的结尾。

\B　　不是单词的边界。不是前边界就放在该部分的前面，不是后边界就放在该部分的后面，例：\BH 表示匹配H，H不是某个单词的开头；H\B表示匹配H，H不是某个单词的结尾。

以上均是对一个字符、（子）表达式位置的说明。

使用正则表达式有两种方式：使用String类的方法，使用Pattern+Matcher两个类。

1、使用String类的方法：

boolean matches(String regex) 该串中是否有匹配。此方法是整串匹配，即该串整个是regex的一个匹配才返回true。比如"hello".matches(“hello”)返回true，“hello”.matches(“he”)返回false。

String replaceFirst(String regex,String replacement)　　替换第一个匹配，返回替换后的串。若无匹配，则返回原串。

String replaceAll(String regex,String replacement) 替换所有的匹配，返回替换后的串。若无匹配，则返回原串。

String[] split(String regex) 以regex作为分隔符，把该串分割成多个子串

String Arrays.toString(String[] arr) 将String[]连接成一个字符串并返回。静态方法。

示例：

package test;

public class Test{
public static void main(String[] args){
String str=“hello world!”;
System.out.println(str.replaceFirst(“h”,“H”)); //Hello world!
//正则表达式是\w，但放在"“内，\要转义为\
System.out.println(str.replaceFirst(”\w",“H”)); //Hello world!
}
}

2、使用Pattern+Matcher两个类

Pattern对象是正则表达式编译后在内存中的表示形式，需要先调用Pattern类的静态方法compile(String regex)将正则表达式编译为Pattern对象：

Pattern p=Pattern.compile("\w"); //参数为正则表达式

再使用Pattern对象的matcher(String str)获取Matcher对象：

Matcher m=p.matcher(“hello world!”); //参数为字符串（用上面的regex匹配这个字符串）

之后就可以用Matcher对象的方法来匹配该串：

boolean b=m.matches(); //是否有匹配，这个方法是整串匹配。注意上面是er，这里是es。

boolean b=m.find(); //是否有匹配，该串中有匹配就返回true。

String str=m.replaceFirst(String replacement); //用指定字符串替换第一个匹配，返回替换后的串

String str=m.replaceAll(String replacement); //用指定字符串替换所有匹配，返回替换后的串

示例：

package test;

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

public class Test{
public static void main(String[] args){
Pattern p=Pattern.compile("\bhe");
Matcher m=p.matcher(“hello world!”);
System.out.println(m.find()); //true
System.out.println(m.matches()); //false
System.out.println(m.replaceFirst(“He”)); //Hello world!
System.out.println(m.replaceAll(“He”)); //Hello world!
}
}

上面的Pattern对象可以重复使用，就是说可以直接使用这个正则表达式去匹配其它的字符串。

如果某个正则表达式只需要使用一次，可以这样：

Boolean b=Pattern.matches(String regex,String str); //会把regex编译成匿名的Pattern对象，并执行匹配

注意：只有matches()方法可以这样用。mathces()是Pattern的静态方法。

数量匹配模式：

1、Greedy（贪婪模式）：数量表示符默认使用贪婪模式匹配，尽可能多的匹配字符，除非明确使用其它匹配模式。例：

\w{2,5} 　　会尽可能多的匹配，能匹配5个就匹配5个，不行就4个，再不行就3个…

\w? 　　？表示匹配0次或1次，会优先匹配1次，没有才匹配0次。

\w+　　 +表示匹配1次及以上，优先匹配最多次。

2、Reluctant（勉强模式）：尽可能少的匹配字符，也称最小匹配模式。需要在数量表示符后用一个额外的？来说明该部分使用最小匹配模式。例：

\w{2,5}?\w　 \w{2,5}?会优先匹配2个

\w??\w \w?会优先匹配0个

\w+?　　会优先匹配1次

？要放在数量表示符后面，才表示前面该部分采用 最小匹配模式。如果?之前无数量表示符，则？表示匹配0个或1个，会采用贪婪模式。

3、Possessive（占有模式），在数量表示符后面用一个额外的+来说明该部分使用占有模式，不常用。

注意：

Java中的正则表达式一般是放在双引号中的，\需要转义。例：

\w　　对应"\w"

只需要转义\，其它预定义的符号，比如？、（）、*等，不用转义。

原文：https://www.cnblogs.com/chy18883701161/p/10859809.html