java 正则表达 详解

本文查看了很多博客，有许多引进的地方，下面会提到。

菜鸟教程 java 也有所引进。

1.正则表达式

1.1字符类

正则表达式中：(?=X) ，通过零宽度的正 lookahead，即下一个符号为X

[abc]：	代表a或者b，或者c字符中的一个。
[^abc]：	代表除a,b,c以外的任何字符。
[a-z]：	代表a-z的所有小写字符中的一个。
[A-Z]：	代表A-Z的所有大写字符中的一个。
[0-9]：	代表0-9之间的某一个数字字符。
[a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
[a-dm-p]：	a 到 d 或 m 到 p之间的任意一个字符。

1.2逻辑运算符

&&	：并且
|	：或

1.3预定义字符及转义字符

1.3.1 预定义字符

"." ： 匹配任何字符。
"\d"：	任何数字[0-9]的简写；
"\D"：	任何非数字[^0-9]的简写；
"\s"： 空白字符：[ \t\n\x0B\f\r] 的简写
"\S"： 非空白字符：[^\s] 的简写
"\w"：	单词字符：[a-zA-Z_0-9]的简写
"\W"：	非单词字符：[^\w]

1.3.2 正则转义字符

这里参考了一篇博客 ，very good！（https://www.cnblogs.com/stone94/p/13162337.html）

1、两次转义

语言本身的和正则中的。

• ? 像C，C++，java中语言中的转义字符，首先我们应该知道转义字符存在的意义是啥？

? 答：在正常的语法里,如回车、换行、tab键等无法直接表达出来;
那么就需要转移

例子

String str = "\\\"name\\\":\\\"spy\\\"";

在内存中其实是这样（物理上）

\"name\":\"spy\"

• 为什么正则中需要转移字符，我们上面已经知道了，正则中一些字符已经有了含义，比如 ‘ . ’ ，‘ * ‘ 等，所以为了表示这些特殊的字符我们就需要转义了

正则表达式中 \后加一个字符 就表示那个字符。

程序中拿到内存中的字符串，有需要按正则表达式的规则来转义。

所以上例中的真正要匹配的是这样

"name":"spy"

那么在 Java 中，要用正则匹配一个 \，需要

\\\

1.4 数量词(三种模式）

1.4.1 Greedy 数量词

X? : 0次或1次
X* : 0次到多次
X+ : 1次或多次
X{n} : 恰好n次
X{n,} : 至少n次
X{n,m}: n到m次(n和m都是包含的)

1.4.2 Reluctant 数量词

X?? : 0次或1次
X*? : 0次到多次
X+? : 1次或多次
X{n}? : 恰好n次
X{n,}? : 至少n次
X{n,m}?: n到m次(n和m都是包含的)

1.4.3 Possessive 数量词

X?+ : 0次或1次
X*+ : 0次到多次
X++ : 1次或多次
X{n}+ : 恰好n次
X{n,}+ : 至少n次
X{n,m}+: n到m次(n和m都是包含的)

1.4.4 三个模式的区分与比较

Greedy —-贪婪的
/*
它的匹配方式是先把整个字符串吞下，然后匹配整个字符串，如果不匹配，就从右端吐出一个字符，再进行匹配，直到找到匹配或把整个字符串吐完为止。
*/
Reluctant —-勉强的，不情愿的
/*
它先从最小匹配开始，先从左端吞入一个字符，然后进行匹配，若不匹配就再吞入一个字符，直到找到匹配或将整个字符串吞入为止。
*/
Possessive—-所有的，所有格的
/*
直接匹配整个字符串，如果完全匹配就匹配成功，否则匹配失败。效果相当于equals()。
*/

1.5正则表达式的使用

1.5.1 与 java.util.regex 包中的一些类结合使用

• Pattern 类

pattern 对象是一个正则表达式的编译表示。

Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

String str ="123a212"
String Regx = "/d?";
Pattern pattern = Pattern.compile(Regx);
/*
Pattern.compile(Regx);
-参数	正则表达式
-该方法是一个静态方法
-返回值 是一个 Pattern 对象
*/

常用方法

Pattern类参考了（https://www.cnblogs.com/sparkbj/articles/6207103.html）

boolean b = Pattern.matches("a*b", "aaaaab");

/*等价于Matcher中举的例子

这个可用于多线程安全使用
*/

• Matcher 类

? Matcher 对象是对输入字符串进行解释和匹配操作的引擎。

? Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

得到 Matcher 对象

String str ="123a212"
String Regx = "/d?";
Pattern pattern = Pattern.compile(Regx);
Matcher matcher = pattern.matcher(str);

知道如何得到对象，我们来看看有哪些常用的方法？

/*	等价于Pattern中举的例子*/

Pattern p = Pattern.compile("a*b"); 
Matcher m = p.matcher("aaaaab"); 
boolean b = m.matches();

/*	适用于多次匹配，但不安全*/

a.索引方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sRBlpMKB-1600162897637)(C:\Users\29841\AppData\Roaming\Typora\typora-user-images\image-20200915171209625.png)]

public static void main( String args[] ){

String REGEX = "\\bcat\\b";
//\b匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
String INPUT ="cat cat cat cattie cat";
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // 获取 matcher 对象
int count = 0;

while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}

(C:\Users\29841\AppData\Roaming\Typora\typora-user-images\image-20200915172145366.png)]

b.查找方法

c.替换方法

replaceFirst() 和 replaceAll()

private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " + "All dogs say meow.";
private static String REPLACE = "cat";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
System.out.println(m.replaceFirst(REPLACE));
System.out.println(m.replaceAll(REPLACE));
}

appendReplacement() 和 appendTail ()

private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoobkkk";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// 获取 matcher 对象
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}

/*
-foo-foo-foo-kkk
*/

• PatternSyntaxException

? PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

1.5.2 与 String 类中的方法结合使用

1.5.3 捕获组

? 捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：

• ((A)(B( C )))

• (A)

• (B( C ))

• ( C )

? 可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。

? 还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

//按指定模式在字符串查找
String line = "This order was placed for QT3000! OK?";
String pattern = "(\\D*)(\\d+)(.*)";

// 创建 Pattern 对象
Pattern r = Pattern.compile(pattern);

// 现在创建 matcher 对象
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
//
System.out.println("Found value: " + m.group(2) );
System.out.println("Found value: " + m.group(3) ); 
} else {
System.out.println("NO MATCH");
}

java 正则表达 详解

原文：https://www.cnblogs.com/bai-li-xi/p/13675513.html