定义

正则表达式（Regular Expression）是一种文本模式匹配的工具，可以用来搜索、替换或提取文本中的模式。它可以用来检查文本是否符合某种模式，或者从文本中提取出符合某种模式的部分

一般用法

未分组

public static void main(String[] args) {
        String str = "1234i的风格送佛i给1352是对方能够普诺斯123 当时法国境内官服4567";
        String regStr = "\\d\\d\\d\\d";
        //创建模式对象
        Pattern pattern = Pattern.compile(regStr);
        //创建匹配器
        Matcher matcher = pattern.matcher(str);
        //开始匹配
        /**
         * matcher.find()
         * 1. 定位满足规则的字符串
         * 2. 找到后，将子字符串的索引记录到matcher对象的属性int[] groups
         *    groups[0]记录第一个子字符串开始的索引，在本例是0，groups[1]记录子字符串结束的索引+1，在本例是4
         * 3. 同时将子字符串结束的索引+1的值记录在oldList中下次执行find方法时，就从该位置开始匹配，在本例是4
         * 4. 重复以上规则
         */
        /**
         * matcher.group(0)
         * 返回找到的子字符串
         */
        while (matcher.find()) {
            System.out.println(matcher.group(0));
        }
    }

分组

正则表达式使用 () 分组，比如 (\d\d)(\d\d)，分成了两组

public static void main(String[] args) {
        String str = "1234i的风格送佛i给1352是对方能够普诺斯123 当时法国境内官服4567";
        String regStr = "(\\d\\d)(\\d\\d)";
        //创建模式对象
        Pattern pattern = Pattern.compile(regStr);
        //创建匹配器
        Matcher matcher = pattern.matcher(str);
        //开始匹配
        /**
         * matcher.find()
         * 1. 定位满足规则的字符串,比如(12)(34)
         * 2. 找到后，将子字符串的索引记录到matcher对象的属性int[] groups
         *      2.1 groups[0] = 0 , 把该子字符串的结束的索引+1 的值记录到 groups[1] = 4
         *      2.2 记录 1 组()匹配到的字符串 groups[2] = 0 groups[3] = 2
         *      2.3 记录 2 组()匹配到的字符串 groups[4] = 2 groups[5] = 4
         *      2.4.如果有更多的分组....
         * 3. 同时将子字符串结束的索引+1的值记录在oldList中下次执行find方法时，就从该位置开始匹配，在本例是4
         * 4. 重复以上规则
         */
        /**
         * matcher.group()
         * 返回找到的子字符串
         */
        while (matcher.find()) {
            /**
             * matcher.group(0)：表示匹配整个子字符串
             * matcher.group(1)：表示匹配整个子字符串的第一个分组
             */
            System.out.println(matcher.group(0));
            System.out.println("第一组数据：" + matcher.group(1));
            System.out.println("第二组数据：" + matcher.group(2));
        }
​
    }

语法

转义字符- \\

需要用到转义字符的有：

 

字符匹配符

 

\\w 也可以找到下划线 _

\\s 匹配任何空白字符(空格,制表符等)
String regStr = "\\s";
\\S 匹配任何非空白字符 ,和\\s 刚好相反
String regStr = "\\S";
. 匹配出 \n 之外的所有的单个字符,如果要匹配.本身则需要使用 \\. 
String regStr = "\\.";
String regStr = ".";

不区分大小写方案

• (?!) 在其之后的字符不区分大小写

  1. (?i)abc表示abc不区分大小写

  2. a(?i)bc表示bc不区分大小写

  3. a()(?i)b)c表示b不区分大小写

• 创建 Pattern 对象时，指定 Pattern.CASE_INSENSITIVE, 表示匹配是不区分字母大小写

  Pattern pattern = Pattern.compile(regStr, Pattern.CASE_INSENSITIVE);

示例

String regStr = "[a-z]";//匹配 a-z 之间任意一个字符
String regStr = "abc";//匹配 abc 字符串[默认区分大小写]
String regStr = "(?i)abc";//匹配 abc 字符串[不区分大小写]
String regStr = "[0-9]";//匹配 0-9 之间任意一个字符
String regStr = "[^a-z]";//匹配 不在 a-z 之间任意一个字符
String regStr = "[abcd]";//匹配 在 abcd 中任意一个字符
String regStr = "\\D";//匹配 不在 0-9 的任意一个字符
String regStr = "\\W";//匹配 等价于 [^a-zA-Z0-9_]

选择匹配符

| 匹配符号两边的表达式

String regStr = "[123]|[abc]";

限定符

用于指定其前面的字符或组合项连续出现多少次，Java默认贪婪匹配（尽可能多匹配）

符号	含义	实例	说明	匹配的字符串
*	指定字符重复0次或n次	(ab)*	包含任意个ab的字符串	ab，ababab
+	指定字符重复1次或n次，至少一次	abc+	以ab开头的以至少一个c结尾的字符串	abc，abccc
?	指定字符重复0次或1次	ab?	a或ab	a，ab
{n}	指定字符重复n次	ab{2}	a加上2个b	abb
{n,}	指定字符至少重复n次	ab{2,}		abb,abbbb
{n,m}	指定字符至少重复n次最多m次	ab{2,3}		abb,abbb

定位符

规定匹配的字符串出现的位置，比如开始或结束的位置，正对原字符串

符号	含义	实例	说明	匹配的字符串
^	指定原字符串起始字符	^[0-9]+[a-z]*	至少一个数字开头的、与任意个小写字母相连的字符串	1fhgd，45dd
$	指定原字符串结束字符	^[0-9]\\-[a-z]+$	以一个数字和-开头的、与任意个小写字母结尾的字符串	1-as
\\b	匹配原字符串的边界的尾部	zzp\\b	边界是指原字符串的空格和结束的位置	vczzp jdzzp
\\B	和\\b相反	zzp\\B	和\\b相反	zzp123 zzp123

分组

捕获分组

构造形式	说明
(pattern)	非命名捕获，编号为零时整个子字符串，其他分组从1开始编号
(?<name>pattern)/(?'name'pattern)	命名捕获，可以使用编号或名称来获取分组,name不能包含标点符号，不能以数字开头

非捕获分组

匹配pattern但不捕获该匹配的字符串

构造形式	说明
(?:pattern)	适用于I或or的情形，如zzp1|zzp2==zzp(?:1|2)
(?=pattern)	zzp(?=1|2)可以匹配zzp1和zzp2中的zzp，而不能匹配zzp3中的zzp
(?!pattern)	与上个相反

非贪婪匹配

Java正则表达式默认是贪婪匹配，在其他限定符（*、+、?、{*n*}、{*n*,}、{*n*,*m*}）之后添加 ? 时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"

正则表达式三个常用类

java.util.regex包主要包括三个类：Matcher,Pattern, PatternSyntaxException

• Pattern

  pattern是一个正则表达式对象，没有公共的构造方法，需要创建对象时，使用其静态方法

  它的方法matches可以用于整体匹配

  public static boolean matches(String regex, CharSequence input) 
  Pattern.matches("zzp.*","zzp123")

 

 

反向引用

圆括号的内容被捕获后可以在之后被使用，叫做反向引用，既可以在正则表达式的内部使用也可以在外部使用

内部反向引用 \\分组号，外部反向引用 $分组号

连续两个相同的数字
String regStr = "(\\d)\\1";
连续五个相同的数字
String regStr = "(\\d)\\1{5}";
一个首尾相同的、中间两个也相同的数字
String regStr = "(\\d)(\\d)\\2\\1";
外部的反向引用，用第一个分组替换匹配到的字符串
content = matcher.replaceAll("$1");

String类中的正则表达式

替换功能

String 类 public String replaceAll(String regex,String replacement)
String str = "zzp12453456";
str = str.replaceAll("z|p", "o");

判断功能

String 类 public boolean matches(String regex){}	//属于整体匹配
String str = "zzp123456";
System.out.println(str.matches("zzp.+"));

分割功能

String 类 public String[] split(String regex)
String str = "zzp123dfnj45s df6dsf";
String[] strings = str.split(" |\\d+");

样例

汉字
String regStr = "^[\u0391-\uffe5]+$"

邮政编码 要求：1.是 1-9 开头的一个六位数. 比如：123890 
String regStr = "^[1-9]\\d{5}$"

QQ 号码 // 要求: 是 1-9 开头的一个(5 位数-10 位数) 比如: 12389 , 1345687 
String regStr = "^[1-9]\\d{4,9}$"

手机号码 // 要求: 必须以 13,14,15,18 开头的 11 位数 , 比如 13588889999 
String regStr = "^1[3|4|5|8]\\d{9}$"
    
URL
String regStr = "^((http|https)://)?([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";//注意：[. ? *]表示匹配就是.?*本身