基础符号
首尾匹配^：匹配输入字符串开始的位置
$：匹配输入字符串结尾的位置
例："^hello$"含义为该字符串开头必须为h，结尾必须为oprivate static void demo1() {
String content = "hello";
String pattern = "^hello$";
boolean isMatch = Pattern.matches(pattern, content);
System.out.println(content + "与" + pattern + "是否匹配？" + isMatch);
}匹配数量：*：0个或多个
+：一个或多个
？：0个或1个
{n}：n个
{n,}：n到无穷多个
{n,m}：n到m个
例：
匹配0-6个hprivate static void demo2() {
String[] s = {"h", "hh", "hhh", "hhhh", "hhhhh", "hhhhhh"};
String[] p = {"h+", "h*", "h?", "h{3}", "h{3,}", "h{3,5}"};
for (String content : s) {
for (String pattern : p) {
boolean isMatch = Pattern.matches(pattern, content);
System.out.println(content + "\t与\t" + pattern + "\t是否匹配？\t" + isMatch);
}
}
}h+h*h?h{3}h{3,}h{3,5}空字符串011000
h111000
hh110000
hhh110111
hhhh110011
hhhhh110011
hhhhhh110010捕获方式：(pattern)：()表示捕获分组，()会把每个分组里的匹配的值保存起来，从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推
(?:pattern)：表示非捕获分组，和捕获分组唯一的区别在于，非捕获分组匹配的值不会保存起来
(?=pattern)：正向肯定预查，匹配pattern前面的位置。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。
(?!pattern)：正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。
(?<=pattern)：反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。
(?
方括号：
[xyz]：匹配x或y或z
[^xyz]：匹配除了x、y、z的其他字符
[a-z]：匹配小写字母
转义：\b\B：\b匹配一个字边界，即字与空格间的位置。例如，"lo\b"匹配"hello"中的"ol"，但不匹配"look"中的"lo"。\B反之。
\cx：\cx 匹配control + 控制字符\cI 匹配 control + I，等价于 \t，
\cJ匹配 control + J，等价于 \n,
\cM匹配 control + M，等价于 \r
\ca \cb \cc ... 又分别匹配 control+a, control+b,control+c....，看运行的程序而定
\d\D：\d匹配数字。\D匹配非数字
\f：匹配分页符。等效于 \x0c 和 \cL。
\n：匹配换行符。等效于 \x0a 和 \cJ。
\r：匹配回车符。等效于 \x0d 和 \cM。
\s\S：\s匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\t：制表符匹配。与 \x09 和 \cI 等效。cv
\v：匹配垂直制表符。与 \x0b 和 \cK 等效。
\w\W：\w匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。\W反之
捕获组
从正则表达式左侧开始，每出现一个左括号"("记做一个分组，分组编号从1开始。0代表整个表达式。而命名则在括号中加入?给其命名
比如对于时间字符串：2019-01-20，表达式如下：(?\\d{4})-(?(?\\d{2})-(?\\d{2}))
有4个左括号，所以有4个分组：编号名称捕获组匹配00(\d{4})-((\d{2})-(\d{2})) 整体2019-01-20
1year(\d{4})2019
2md((\d{2})-(\d{2}))01-20
3month(\d{2})01
4date(\d{2})20
示例代码：
private static void demo5() {
Pattern p = Pattern.compile("(\\d{4})-((\\d{2})-(\\d{2}))");
Matcher m = p.matcher("2019-01-20");
m.find();
System.out.println("m.group(0) value: "+m.group(0));
System.out.println("m.group(1) value: "+m.group(1));
System.out.println("m.group(2) value: "+m.group(2));
System.out.println("m.group(3) value: "+m.group("month"));
System.out.println("m.group(4) value: "+m.group("date"));
}
//输出：
//m.group(0) value: 2019-01-20
//m.group(1) value: 2019
//m.group(2) value: 01-20
//m.group(3) value: 01
//m.group(4) value: 20Java常用类
Pattern 类：pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
Matcher 类：Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
PatternSyntaxException类：是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
Matcher方法
索引方法序号方法说明1public int start()返回以前匹配的初始索引。
2public int start(int group)返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
3public int end()返回最后匹配字符之后的偏移量。
4public int end(int group)返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
public class RegexMatches {
public static void main(String[] args) {
Pattern p = Pattern.compile("\\bwen\\b");
Matcher m = p.matcher("wen wen wenXXX wen"); // 获取 matcher 对象
int count = 0;
while (m.find()) {
count++;
System.out.print("第" + count+"个匹配值 ");
System.out.print("起始索引: " + m.start());
System.out.print(" 结束索引: " + m.end());
System.out.println();
}
}
private static void demo() {
Pattern p = Pattern.compile("(\\d{4})-((\\d{2})-(\\d{2}))");
Matcher m = p.matcher("2019-01-20");
m.find();
for(int i=0;i<5;i++){
System.out.println("第"+i+"个组"+"索引 "+m.start(i)+" 值："+m.group(i));
}
}
}main输出：第1个匹配值 起始索引: 0 结束索引: 3
第2个匹配值 起始索引: 4 结束索引: 7
第3个匹配值 起始索引: 15 结束索引: 18
demo输出：第0个组索引 0 值：2019-01-20
第1个组索引 0 值：2019
第2个组索引 5 值：01-20
第3个组索引 5 值：01
第4个组索引 8 值：20
查找方法序号方法说明1public boolean lookingAt()判断开头区域是否与正则表达式匹配。
2public boolean find()尝试查找与该表达式匹配的输入序列的下一个子序列。
3public boolean find(int start)重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
4public boolean matches()判断整个区域是否与正则表达式匹配。
例：
public class RegexMatches2 {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("foo");
Matcher matcher = pattern.matcher("fooooooooooooooooo");
Matcher matcher2 = pattern.matcher("ooooofoooooooooooo");
System.out.println("lookingAt(): " + matcher.lookingAt());
System.out.println("matches(): " + matcher.matches());
System.out.println("lookingAt(): " + matcher2.lookingAt());
}
}输出：
lookingAt(): true
matches(): false
lookingAt(): false替换方法序号方法说明1public Matcher appendReplacement(StringBuffer sb, String replacement)实现非终端添加和替换步骤。
2public StringBuffer appendTail(StringBuffer sb)实现终端添加和替换步骤。
3public String replaceAll(String replacement)替换模式与给定替换字符串相匹配的输入序列的每个子序列。
4public String replaceFirst(String replacement)替换模式与给定替换字符串匹配的输入序列的第一个子序列。
5public static String quoteReplacement(String s)返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。
replaceAll案例：
private static void demo1() {
String dog = "I have a dog. The dog very cute.";
Pattern p = Pattern.compile("dog");
Matcher m = p.matcher(dog);
dog = m.replaceAll("cat");
System.out.println(dog);
}输出：
I have a cat. The cat very cute.
replaceFirst案例：
private static void demo2() {
String dog = "I have a dog. The dog very cute.";
Pattern p = Pattern.compile("dog");
Matcher m = p.matcher(dog);
dog = m.replaceFirst("cat");
System.out.println(dog);
}输出：
I have a cat. The dog very cute.
appendReplacement 和 appendTail 方法private static void demo3() {
Pattern p = Pattern.compile("a*b");
// 获取 matcher 对象
Matcher m = p.matcher("aabfooaabfooabfoobkkk");
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,"-");
System.out.println(sb.toString());
}
m.appendTail(sb);
System.out.println(sb.toString());
}
