? 正则表达式，本质上就是字符串，是一种规则，用来匹配，搜索，编辑，操作文本的，java中提供了java.util.regex包来与正则表达式进行模式匹配。
? 下面以一个简单的例子看看正则表达式，会有个更直观的印象：
public class RegexDemo1 {
public static void main(String[] args) {
Pattern p = Pattern.compile("[0-9]{2,3}");
Matcher m = p.matcher("123");
System.out.println(m.matches());// 输出： true
}
}? 上述例子中[0-9]{2,3}就是所谓的正则表达式，{2,3}是匹配由至少2个数字，至多3个数字的字符串，前面[0-9]是指数字0-数字9，也就是十个数字。
? java中提供了java.util.regex包，包里提供了两个类：Pattern和Matcher
? Pattern就是一种模式，利用它的静态方法compile，编译正则表达式，得到一种匹配的模式，再利用matcher方法进行字符串的匹配，得到匹配结果Matcher，最后由Matcher处理结果。
static Pattern compile(String regex)：将给定的正则表达式编译到模式中。Matcher matcher(CharSequence input)：创建匹配器，返回Matcher类实例。String[] split(CharSequence input)：将匹配到的数据拆分。boolean matches()：执行匹配验证，当整个匹配时才返回true。String replaceAll(String replacement)：替换字符串。String group(int group)：返回指定组的匹配数据。? 字符串String类对正则表达式有四个内置的可以运行正则表达式的方法，分别是：matches()，split() ,replaceAll()，replaceFirst()
? 注意：replace()函数是不支持正则表达式的！
boolean matchers(String regex)：当且仅当整个字符串匹配时返回true。String[] split(String regex)：根据给定的正则表达式的匹配来拆分字符串。String replaceAll(String regex, String replacement)：使用给定的replacement替换字符串所有匹配给定正则表达式的子字符串。String replaceFirst(String regex, String replacement)：使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。public class RegexDemo2 {
public static void main(String[] args) {
String s = "hello java abc";
boolean s1 = s.matches("hello java");
System.out.println(s1);
System.out.println("------------------------");
String[] s2 = s.split("\\s");
for (String s0 : s2) {
System.out.println(s0);
}
System.out.println("-------------------------");
String s3 = s.replaceAll("\\s", "+");
System.out.println(s3);
System.out.println("-------------------------");
String s4 = s.replaceFirst("\\s", "-");
System.out.println(s4);
System.out.println("-------------------------");
}
}输出结果：
false
------------------------
hello
java
abc
-------------------------
hello+java+abc
-------------------------
hello-java abc
-------------------------常见的匹配符号
.
匹配所有的单个字符，除了换行符。
^regex
匹配以字符串开头
regex$
匹配以字符串结尾
[abc]
复选集定义，匹配字符a,或b，或c
[^abc]
在中括号中插入^符号，表示否定模式
匹配所有的字符，除了a,b,c三个
[a-z1-9]
表示范围的匹配，匹配字母a到z和数字1到9，比如可以匹配到a4
a|b
或的选择，可以匹配a或者b，只会二选一
元字符
\d
匹配一个数字，相当于是[0-9]的简写，当要匹配一个数字时，可以直接写\d，简化了写[0-9]
\D
匹配一个非数字，相当于是[^0-9]的简写
\s
匹配一个空格，包括tab键(\t)
\S
匹配一个非空格
\w
匹配一个单词字符(包括大小写字母，数字，下划线),相当于是[a-zA-Z0-9_]的简写
\W
匹配一个非单词字符(就是除了大小写字母，数字和下划线之外的字符)
限定符
*：
匹配大于等于0个任意字符，可以是0个，也可以是无数个。
比如：X*表示匹配0个或者任意多个字符X，.*则表示匹配任何字符串
+：
匹配大于等于1个任意字符，至少是1个，可以是无数个。
?：
匹配0个或1个任意字符，至少是0个，至多是1个。
{n}：
表示只匹配n个任意字符。
{n,m}：
表示只匹配n-m个任意字符，最少n个，最多m个。
*?：
如果？是限定符*,+,?或者{}后面的第一个字符，那么表示这是一种非贪婪模式
非贪婪模式：就是指尽可能的少匹配，默认的是贪婪模式。
比如c(.*)b,默认是贪婪模式，是尽可能多匹配，而.*是匹配任意字个符，那么在匹配caabaabaab时，因为贪婪模式，中间的字符都属于匹配范围，只要最后一个b，最后匹配结果是：caabaabaab
而c(.*?)b,则是非贪婪匹配，是尽可能少的匹配，所以对于.*，应该是尽快能少的取,所以对于caabaabaab会被匹配，但是匹配得到是caab,中间尽量少匹配字符，所以在遇到第一个b时候结束匹配了。
public class RegexDemo3 {
public static void main(String[] args) {
Pattern p = Pattern.compile("c.*b");
Matcher m = p.matcher("caabaabaab");
if (m.find()) {
System.out.println("caabaabaab matches: " + m.group(0));
} // 输出：caabaabaab matches: caabaabaab
Pattern p1 = Pattern.compile("c.*?b");
Matcher m1= p1.matcher("caabaabaab");
if (m1.find()) {
System.out.println("caabaabaab matches: " + m1.group(0));
}// 输出：caabaabaab matches: caab
}
}分组
使用小括号()，可以起到对正则表达式进行分组的作用，这样子我们可以使用Matcher类的group()函数来获取。
分组之后的引用也分为几种：
分组和反向引用
使用分组后会在正则表达式中创建反向引用，反向引用会保存匹配到的字符串片段，后续可以直接通过$来引用，$0表示匹配到的完整模式的字符串，$1表示第一个分组的反向引用，$2表示第二个分组的方向引用，依次类推.......
public class RegexDemo4 {
public static void main(String[] args) {
// 去除空格，得到Hello,java!
String str = "Hello , java !";
String p = "(\\w)(\\s+)([,!])";
System.out.println(str.replaceAll(p, "$1$3"));
// 输出：Hello, java!
}
}解析：String p = "(\w)(\s+)([,!])";
这一个正则表达式分了三个组：
$0 会匹配(\w)(\s+)([,!])的结果，也就是o空格,和a空格!
$1 会匹配(\w)的结果，也就是o和a
$2 会匹配(\s+)的结果，也就是空格和空格
$3 会匹配[,!]的结果，也就是,和!
所以在调用replaceAll时，所有匹配到的结果，也就是o空格,会被替换为$1$3匹配到的结果o,，而a空格!也会被替换为$1$3匹配的结果a!
分组但不反向引用---(?:)
如果我们在小括号内开头加入?:，那么这个模式就只是分组，不会创建方向引用。
将上面代码做下小修改，如下：
public class RegexDemo4 {
public static void main(String[] args) {
// 去除空格，得到Hello,java!
String str = "Hello , java !";
String p = "(?:\\w)(\\s+)([,!])";
System.out.println(str.replaceAll(p, "$1$3"));
}
}这样子将会报一个错误：
Exception in thread "main" java.lang.IndexOutOfBoundsException: No group 3
因为第一个分组(\w)被改为了(?:\w)，只是分组，不会创建反向引用，所以这时候就没有3个反向引用了，只有两个，所以找不到group 3
分组的反向引用的副本
在使用反向引用时候，也可以不用$去引用，而是使用一个别名，也就是反向引用的副本，只要在小括号中加入?<name>，就会把反向引用保存为一个名字为name的副本了，后续使用时候直接使用name就可以得到反向引用。
public class RegexDemo4 {
public static void main(String[] args) {
// 去除空格，得到Hello,java!
String str = "Hello,java";
Pattern p = Pattern.compile("(?<First>\\w*),(?<Second>\\w*)");
Matcher m = p.matcher(str);
while (m.find()) {
System.out.println(m.group(1));// 输出：Hello
System.out.println(m.group("First"));// 输出：Hello
System.out.println(m.group(2));// 输出：java
System.out.println(m.group("Second"));// 输出：java
}
}
}指定正则表达式的模式
可以在正则表达式语句的开头指定模式，有以下几种模式可以指定：
原文：https://www.cnblogs.com/LucasBlog/p/12452007.html