Java正则表达式以及Pattern和Matcher类详解

概述

正则表达式

一、概述

用来描述或者匹配一系列符合某个语句规则的字符串

二、单个符号

1、英文句点.符号：匹配单个任意字符。

表达式t.o可以匹配：tno，t#o，teo等等。不可以匹配：tnno，to，Tno，t正o等。
2、中括号[]：只有方括号里面指定的字符才参与匹配，也只能匹配单个字符。

表达式：t[abcd]n 只可以匹配：tan，tbn，tcn，tdn。不可以匹配：thn，tabn，tn等。
3、| 符号。相当与“或”，可以匹配指定的字符，但是也只能选择其中一项进行匹配。

表达式：t(a|b|c|dd)n 只可以匹配：tan，tbn，tcn，tddn。不可以匹配taan，tn，tabcn等。
4、表示匹配次数的符号

表达式：[0—9]{3}\—[0-9]{2}\—[0-9]{3} 的匹配格式为：999—99—999因为—符号在正则表达式中有特殊的含义，它表示一个范围，所以在前面加转义字符\。

5、^符号：匹配输入字符的开始位置。如果用在方括号内，^表示不想匹配的字符。

表达式：[^x] 第一个字符不能是x
6、\S符号：非空字符
7、\s符号：空字符，只可以匹配一个空格、制表符、回车符、换页符，不可以匹配自己输入的多个空格。
8、\r符号：空格符，与\n、\tab相同

三、元字符及其在正则表达式上下文中的行为

元字符	在正则表达式中的行为
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的Multiline 属性，^ 也匹配 \n或 \r之后的位置
$	匹配输入字符串的结束位置。如果设置了 RegExp 对象的Multiline 属性，$ 也匹配 \n或 \r之前的位置
*	匹配前面的子表达式零次或多次，*等价于{0,}
+	匹配前面的子表达式一次或多次，+ 等价于 {1,}
?	匹配前面的子表达式零次或一次，? 等价于 {0,1} 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {m,n}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。
{n}	n 是一个非负整数，匹配确定的n 次
{n,}	n 是一个非负整数，至少匹配n 次
{m,n}	m 和 n 均为非负整数，其中m <= n。最少匹配 m 次且最多匹配 n 次。在逗号和两个数之间不能有空格
.	匹配除 \n之外的任何单个字符。要匹配包括 \n 在内的任何字符，请使用像 [.\n]的模式
(pattern)	匹配pattern 并捕获这一匹配。获取匹配结果以后可以用于分组。
(?:pattern)	匹配pattern 但不捕获匹配结果，也就是说这是一个非捕获匹配，不进行存储供以后使用
(?=pattern)	正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用
(?!pattern)	负向预查，与(?=pattern)作用相反
x|y	匹配 x 或 y
[xyz]	字符集合，匹配[]里面的字符，即x或y或z
[^xyz]	否定字符集合，匹配[]之外的字符，比如a、b、c等
[a-z]	字符范围，匹配指定范围内的任意字符，如a、b、c等
[^a-z]	否定字符范围，匹配任何不在指定范围内的任意字符
\b	匹配一个单词边界，也就是指单词和空格间的位置
\B	匹配非单词边界
\cx	匹配由x指明的控制字符
\d	匹配一个数字字符，等价于 [0-9]
\D	匹配一个非数字字符，等价于 [^0-9]
\f	匹配一个换页符。等价于 \x0c 和 \cL
\n	匹配一个回车符，等价于 \x0d 和 \cM
\s	匹配任何空白字符，包括空格、制表符、换页符等等，等价于[ \f\n\r\t\v]
\S	匹配任何非空白字符，等价于 [^ \f\n\r\t\v]
\t	匹配一个制表符，等价于 \x09 和 \cI
\v	匹配一个垂直制表符，等价于 \x0b 和 \cK
\w	匹配包括下划线的任何单词字符，等价于[A-Za-z0-9_]
\W	匹配任何非单词字符，等价于 [^A-Za-z0-9_]

四、常用正则表达式整理

• 匹配中文字符的正则表达式： [\u4e00-\u9fa5]
• 匹配空行的正则表达式：\n[\s| ]*\r
• 匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/
• 匹配首尾空格的正则表达式：(^\s*)|(\s*$)
• 匹配IP地址的正则表达式：/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //
• 匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
• 匹配网址URL的正则表达式：http://(/[\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?
• sql语句：^(select|drop|delete|create|update|insert).*$
• 非负整数：^\d+$
• 正整数：^[0-9]*[1-9][0-9]*$
• 非正整数：^((-\d+)|(0+))$
• 负整数：^-[0-9]*[1-9][0-9]*$
• 整数：^-?\d+$
• 非负浮点数：^\d+(\.\d+)?$
• 正浮点数：^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
• 非正浮点数：^((-\d+\.\d+)?)|(0+(\.0+)?))$
• 负浮点数：^(-((正浮点数正则式)))$
• 英文字符串：^[A-Za-z]+$
• 英文大写串：^[A-Z]+$
• 英文小写串：^[a-z]+$
• 英文字符数字串：^[A-Za-z0-9]+$
• 英数字加下划线串：^\w+$
• E-mail地址：^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$
• URL：^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$
• 邮政编码：^[1-9]\d{5}$
• 电话号码：^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$
• 手机号码：^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$
• 双字节字符(包括汉字在内)：^\x00-\xff
• 匹配首尾空格：(^\s*)|(\s*$)
• 提取信息中的网络链接：(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?
• 提取信息中的邮件地址：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
• 提取信息中的图片链接：(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?
• 提取信息中的IP地址：(\d+)\.(\d+)\.(\d+)\.(\d+)
• 提取信息中的中国手机号码：(86)*0*13\d{9}
• 提取信息中的中国固定电话号码：(\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}
• 提取信息中的中国电话号码（包括移动和固定电话）：(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}
• 提取信息中的中国邮政编码：[1-9]{1}(\d+){5}
• 提取信息中的浮点数（即小数）：(-?\d*)\.?\d+
• 提取信息中的任何数字 ：(-?\d*)(\.\d+)?
• 电话区号：/^0\d{2,3}$/
• 腾讯QQ号：^[1-9]*[1-9][0-9]*$
• 帐号(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
• 中文、英文、数字及下划线：^[\u4e00-\u9fa5_a-zA-Z0-9]+$

Pattern和Matcher类详解

概述

• Pattern(模式)类的作用在于编译正则表达式后创建一个匹配模式
• Matcher(匹配)类使用Pattern实例提供的模式信息对正则表达式进行匹配

Pattern类

常用方法及介绍

• Pattern complie(String regex)

​ 由于Pattern的构造函数是私有的，不可以直接创建，所以通过静态方法compile(String regex)方法来创建，将给定的正则表达式编译并赋予给Pattern类。

• String pattern()

  返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

@Test
public void testPattern() {
    
    
    String regex = "\\?|\\*";
    Pattern pattern = Pattern.compile(regex);
    String patternStr = pattern.pattern();//返回\?\*
    System.out.println(patternStr);
}

• Pattern compile(String regex, int flags)

​ 功能和compile(String regex)相同,不过增加了flag参数

• int flags()

  返回当前Pattern的匹配flag参数

  flag参数用来控制正则表达式的匹配行为，可取值范围如下:

Pattern.CANON_EQ 当且仅当两个字符的”正规分解(canonical decomposition)”都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式”a\u030A”会匹配”?”。默认情况下，不考虑”规范相等性(canonical equivalence)”。

Pattern.CASE_INSENSITIVE(?i) 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹 配，只要将UNICODE_CASE与这个标志合起来就行了。

Pattern.COMMENTS(?x) 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注:不是指表达式里的”\s”，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束.可以通过嵌入式的标志来启用Unix行模式。

Pattern.DOTALL(?s)在这种模式下，表达式’.’可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式’.’不匹配行的结束符。

Pattern.MULTILINE(?m)在这种模式下，’^’和’$’分别匹配一行的开始和结束。此外，{’}^{’}仍然匹配字符串的开始，’$’也匹配字符串的结束.默认情况下，这两个表达式仅仅匹配字符串的开始和结束。

Pattern.UNICODE_CASE(?u) 在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。

Pattern.UNIX_LINES(?d) 在这个模式下，只有’\n’才被认作一行的中止，并且与’.’，’^’以及’$’进行匹配。

• Matcher matcher(CharSequence input)

​ 对指定输入的字符串创建一个Matcher对象

@Test
public void testMatcher() {
    
    
    Pattern pattern = Pattern.compile("\\?{2}");
    Matcher matcher = pattern.matcher("??");
    boolean matches = matcher.matches();// true
    System.out.println(matches);
}

• String[] split(CharSequence input)

  分割字符串

• String[] split(CharSequence input, int limit)
  功能和String[] split(CharSequence input)相同，增加参数limit目的在于要指定分割的段数

@Test
public void testSplit() {
    
    
    String regex = "\\?|\\*";
    Pattern pattern = Pattern.compile(regex);
    String[] splitStr = pattern.split("123?123*456*456");//123 123 456 456
    System.out.println(splitStr);
    String[] splitStr1 = pattern.split("123?123*456*456", 2);//123 123*456*456
    System.out.println(splitStr1);
}

• boolean matches()

​ 编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配。该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并不需要生成一个Matcher实例。

@Test
public void testMatches() {
    
    
    String regex = "\\?|\\*";
    Pattern pattern = Pattern.compile(regex);
    boolean matches = pattern.matches(regex, "?");//返回true
    System.out.println(matches);
}

Matcher类

常用方法及介绍

• boolean matches()

​ 最常用方法：尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。

@Test
public void testMatcherMatches() {
    
    
    Pattern pattern = Pattern.compile("\\?{2}");
    Matcher matcher = pattern.matcher("??");
    boolean matches = matcher.matches();//true
    System.out.println(matches);
    matcher = pattern.matcher("?");
    matches = matcher.matches();//false
    System.out.println(matches);
}

• boolean lookingAt()

​ 对前面的字符串进行匹配，只有匹配到的字符串在最前面才会返回true

@Test
public void testLookingAt() {
    
    
    Pattern p = Pattern.compile("\\d+");
    Matcher m = p.matcher("22bb23");
    boolean match = m.lookingAt();//true
    System.out.println(match);
    m = p.matcher("bb2233");
    match= m.lookingAt();
    System.out.println(match);//false
}

• boolean find()

​ 扫描输入序列以查找与该模式匹配的下一个子序列。对字符串进行匹配，匹配到的字符串可以在任何位置

@Test
public void testFind() {
    
    
    Pattern p = Pattern.compile("\\d+");
    Matcher m = p.matcher("22bb23");
    m.find();// 返回true
    Matcher m2 = p.matcher("aa2223");
    m2.find();// 返回true
    Matcher m3 = p.matcher("aa2223bb");
    m3.find();// 返回true
    Matcher m4 = p.matcher("aabb");
    m4.find();// 返回false
}

• int start()

​ 返回当前匹配到的字符串在原目标字符串中的位置

• int end()

​ 返回当前匹配的字符串的最后一个字符在原目标字符串中的索引位置

• String group()

​ 返回匹配到的子字符串

@Test
public void testMore() {
    
    
    Pattern p = Pattern.compile("\\d+");
    Matcher m = p.matcher("aa22bb23");
    m.find();
    int start = m.start();//2
    String group = m.group();//22
    int end = m.end();//4
    System.out.println(start);
    System.out.println(group);
    System.out.println(end);
    m.find();
    start = m.start();//6
    group = m.group();//23
    end = m.end();//8
    System.out.println(start);
    System.out.println(group);
    System.out.println(end);
}

package org.zpli.demo;

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

/**
 * created at 2022/4/22 2:56 下午
 *
 * @author somnuszpli
 */
public class RegexTest {
    
    

    @Test
    public void test1() {
    
    
        String inputStr = "http://localhost:8080/index/marketplaces/80000/pages/helloworld";
        String regex = ".*/index(?:/miniProg)?/(?:industrySites|marketplaces)?/(\\d+)/pages/([^/]+)";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(inputStr);
        while (matcher.find()) {
    
    
            System.out.println(matcher.group(1));
        }
    }

    @Test
    public void testPattern() {
    
    
        String regex = "\\?|\\*";
        Pattern pattern = Pattern.compile(regex);
        String patternStr = pattern.pattern();//返回\?\*
        System.out.println(patternStr);
    }

    @Test
    public void testMatcher() {
    
    
        Pattern pattern = Pattern.compile("\\?{2}");
        Matcher matcher = pattern.matcher("??");
        boolean matches = matcher.matches();// true
        System.out.println(matches);
    }

    @Test
    public void testSplit() {
    
    
        String regex = "\\?|\\*";
        Pattern pattern = Pattern.compile(regex);
        String[] splitStr = pattern.split("123?123*456*456");//123 123 456 456
        System.out.println(splitStr);
        String[] splitStr1 = pattern.split("123?123*456*456", 2);//123 123*456*456
        System.out.println(splitStr1);
    }

    @Test
    public void testMatches() {
    
    
        String regex = "\\?|\\*";
        Pattern pattern = Pattern.compile(regex);
        boolean matches = pattern.matches(regex, "?");//返回true
        System.out.println(matches);
    }

    @Test
    public void testMatcherMatches() {
    
    
        Pattern pattern = Pattern.compile("\\?{2}");
        Matcher matcher = pattern.matcher("??");
        boolean matches = matcher.matches();//true
        System.out.println(matches);
        matcher = pattern.matcher("?");
        matches = matcher.matches();//false
        System.out.println(matches);
    }

    @Test
    public void testLookingAt() {
    
    
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher("22bb23");
        boolean match = m.lookingAt();//true
        System.out.println(match);
        m = p.matcher("bb2233");
        match = m.lookingAt();
        System.out.println(match);//false
    }

    @Test
    public void testFind() {
    
    
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher("22bb23");
        m.find();// 返回true
        Matcher m2 = p.matcher("aa2223");
        m2.find();// 返回true
        Matcher m3 = p.matcher("aa2223bb");
        m3.find();// 返回true
        Matcher m4 = p.matcher("aabb");
        m4.find();// 返回false
    }

    @Test
    public void testMore() {
    
    
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher("aa22bb23");
        m.find();
        int start = m.start();//2
        String group = m.group();//22
        int end = m.end();//4
        System.out.println(start);
        System.out.println(group);
        System.out.println(end);
        m.find();
        start = m.start();//6
        group = m.group();//23
        end = m.end();//8
        System.out.println(start);
        System.out.println(group);
        System.out.println(end);
    }

}