Java 正则表达式

1, 基础

1.1 概念

一般来说,正则表达式就是以某种方式来描述字符串,可以说是一种字符串格式,也就是说如果某个字符串的格式和正则表达式所描述的格式一样,那么这个字符串就是我们要找的字符串.

注意 : 由于语法问题因此各种语言可能对符号的处理不同. 比如 : 在Java中 \\ 表示\ , \\d 表示匹配数字,\\\\ 表示匹配\等 .

代码示例 :
1. -? : 表示可能会有一个负号当然也可能没有 .
2. \\d : 表示一位数字.
3. \\\\: 表示 \
4. \n : 换行
5. \t : 制表符
6. + : 一个或者多个
7. -?\\d+: 一个或没有-开头,后跟一个或者多个数字(至少一个数字).
8. (-|\\+)?\\d+ : 一个(或者没有) (- 或 + 开头),后跟至少一个数字.

1.2 String 类自带了一些正则方法

1.2.1 matches方法

// 使用正则表达式匹配字符串.
System.out.println("-123".matches("-?\\d+"));

1.2.2 split 方法

// 使用正则表达式分割字符串. 分割所有符合条件的位置.
String string = "123-123-345";
String[] strings1 = string.split("-");
// 限制分割次数.
String[] strings2 = string.split("-",1);

1.2.3 字符串替换方法

// 四个字符串替换方法

String string = "123-123-123-123-456-777-faaa-fbbb";
// 将字符 1 替换成 9
System.out.println(string.replace("1", "7"));
// 将字符序列 "23" ---> "89"
System.out.println(string.replace("23", "89"));
// 使用正则表达式,替换所有符合条件的字符
System.out.println(string.replaceAll("123|456|777","000"));
// 使用正则表达式,替换第一个匹配项.
System.out.println(string.replaceFirst("f\\w+", "ewww"));

// 输出
/*
723-723-723-723-456-777-faaa-fbbb  // 1 -> 7
189-189-189-189-456-777-faaa-fbbb  // 23 -> 89
000-000-000-000-000-000-faaa-fbbb  // 123,456,777 都替换成 000
123-123-123-123-456-777-ewww-fbbb  // 第一个 f 开头后跟一个或多个字符 替换成 ewww.
*/

1.3 创建正则表达式

注意 : 正则表达式可以参阅JDK文档 java.util.regex包中的 Pattern 类.

常用正则 1 : 字符

表达式	含义
\\	\
\xhh	字符的ASCii码的十六进制形式.比如 : \\x41 可以匹配 A
\xhhhh	Unicode 字符的ASCii码十六进制表示形式
\t	制表符 Tab ,'\u0009'
\n	换行符 '\u000A'
\r	回车符 '\u000D'
\f	换页符 '\u000C'
\e	转义

常用正则 2 : 字符类

正则表达式	含义
.	任意字符
[abc]	包含a,b或c 的任何字符 ,<==> `a
[^abc]	除了a,b,c 以外的任何字符. ^表示否定
[a-zA-Z]	表示 a 到 z ,A 到 Z 的任何字符.(- 表示范围).
[ab[cd]]	表示 a,b,c,d 中个任意字符.(合并)<==>`a
a-z&&[hij]	表示 h i j 中的任意字符,(&& 表示求 交集)
\s	空白符(空格,tab,换行,回车,换页)
\S	非空白符 <==> [^\s]
\d	数字 <==> [0-9]
\D	非数字[^0-9]
\w	词子符 [a-zA-Z0-9]
\W	非词字符[^\w]

逻辑操作符

正则表达式	含义
XY	Y跟在X后面 (连接)
X竖线Y	X 或 Y
(X)	捕获组.

边界符

正则表达式	含义
^	一行开始
'$'	一行结束
\b	词的边界
\B	非词边界
\G	前一个匹配结束.

1.4 量词

量词描述了一个模式吸收文本的方式有一下三种类型.
1. 贪婪型 : 会为所有可能的模式发现尽可能多的匹配项.
2. 勉强型 : 用问号来指定这个量词匹配满足模式所需要的最少字符.
3. 占有型 : Java特有可以防止状态回溯 .

贪婪型	勉强型	占有型	匹配方式
X?	X??	X?+	一个或者零个(0-1) X
X*	X*?	X*+	零个或者多个(0- ) X
X+	X+?	X++	一个或者多个(1- ) X
X{n}	X{n}?	X{n}+	恰好 n 个 X
X{n,}	X{n,}?	X{n,}+	至少n次 X
X{n,m}	X{n,m}?	X{n,m}+	至少n次,且不多于 m次 X

注意 : 前面的X 最好使用()括起来.比如 : (abc)+.

2, Pattern 和 Matcher 类

2.1 Pattern 类

正则表达式的编译表现形式,可以认为是Java中正则表达式匹配格式对象. 指定为字符串的正则表达式必须先被编译成此类的实例对象, 然后可以创建Matcher对象.该对象可以与任意字符序列匹配.执行匹配的所有状态都保存在Matcher中,所以多个Matcher可以共享一个Pattern对象.

// 将正则表达式编译成 Pattern 对象,(1 或 0 个符号,后跟 至少一个数组[0-9])
Pattern pattern = Pattern.compile("-?\\d+");
// 利用 Pattern 对象生成 Matcher 对象.
Matcher matcher = pattern.matcher("-1234");
// 查看匹配结果 .
System.out.println(matcher.matches());

如果只是使用一次正则表达式可以使用Pattern的静态方法matches

// 使用 Pattern 对象的静态方法执行一次正则匹配.
System.out.println(Pattern.matches("-?\\d+", "123"));

2.2 Matcher 类

Matcher 可以通过解释 Pattern 从而对 字符序列 进行匹配操作. 可以通过调用 Pattern对象的matcher() 方法获取一个 Matcher 对象.

Matcher 的三种匹配操作

• matches : 尝试将整个输入序列与该模式进行匹配.(全序列)
• lookingAt : 尝试将该输入序列从头开始与该模式进行匹配.(序列头子序列)
• find : 扫描输入序列以查找与该模式匹配的下一个子序列.(序列的任意子序列)

Pattern pattern = Pattern.compile("-?\\d+");
Matcher matcher0 = pattern.matcher("12345");
Matcher matcher1 = pattern.matcher("123456aaa");
Matcher matcher2 = pattern.matcher("aa1234aa");
// 进行整个序列匹配,只有整个字符序列满足匹配规则才会返回true.
System.out.println("matches : " + matcher0.matches());
// 从头开始找.只有从头开始的子序列满足匹配规则才会返回true.
System.out.println("lookingAt : " + matcher1.lookingAt());
// 扫描输入序列查找, 只要序列中存在符合条件的子序列则返回true,否则返回false.
System.out.println("find() : " + matcher2.find());
// 扫描从指定位置以后的字符序列的的所有子序列.
System.out.println("find(index) :" + matcher2.find(6));

设置匹配边界

Pattern pattern = Pattern.compile("-?\\d+");
Matcher matcher0 = pattern.matcher("aa12345aa");
// 重置匹配器 设置区域
matcher0 = matcher0.region(2, 4);
System.out.println("匹配器开始位置 : " + matcher0.regionStart());
System.out.println("匹配器结束位置 : " + matcher0.regionEnd());

更新 Pattern

Pattern pattern = Pattern.compile("-?\\d+");
Matcher matcher0 = pattern.matcher("aa12345aa");
System.out.println("匹配数字 : " + matcher0.matches());
Pattern pattern2 = Pattern.compile("\\w+");
// 更换 Pattern 对象.
matcher0.usePattern(pattern2);
System.out.println("匹配字符 : " + matcher0.matches());

// 输出
/*
匹配数字 : false
匹配字符 : true
*/