正则表达式总结

一、常用元字符

\：转义符,其中：
\d：匹配数字字符;\D：匹配非数字字符;
\n：换行符;\r：回车符;\t：制表符;\v：垂直制表符;\f：换页符
\s：匹配任意空字符，等价于[\r\n\t\v\f];\S：匹配任意空字符;

\b：匹配单词边界;\B：匹配非单词边界
\w：匹配包括下划线的任意字符，类似但不等价于[a-zA-Z0-9_]，这里的"单词"使用Unicode字符集;\W：匹配非单词字符，类似[^a-zA-Z0-9_]
\xn：表示16进制转义符，其中n为确定的两个数字长。通常为ASCII编码，常用ASCII，\x30表示0，\x41表示A，\x61表示a
\num：其中num为正整数，表示对前面所获取的匹配的引用。
\n：优先按\num匹配，如果如果前面没有获取匹配为8进制转义符，如\060表示0
\un：其中n为4个16进制数字表示的Unicode字符
\<：匹配词的开始;\>：匹配词的结束
^：字符串开始位置
$：字符串结束位置
*：匹配前面的子表达式任意次
+：匹配前面的子表达式1次或者多次
?：匹配前面的子表达式0次或1次
{n}：匹配前面的子表式n次
{n,}：匹配前面的子表式至少n次
{n,m}：匹配前面的子表式n到m次
?：当该字符紧跟在任何一个其他限制符（*,?,{n},{n,},{n,m}）后面时，匹配模式是非贪婪的，尽量少的匹配所搜索的字符串
.：匹配除[\r\n]外的任意单个字符。如果要匹配任意字符：[\s\S]
()：(和)之间的表达式定义为组，最多可以匹配9个，分别前面的\1到\9相对
|：或

用Java举例如下：

import java.util.regex.Pattern;

public class Test {

	public static void main(String[] args) {
		System.out.println(Pattern.matches("\\x30", "0"));
		System.out.println(Pattern.matches("\\060", "0"));
		System.out.println(Pattern.matches("\\x41", "A"));
		System.out.println(Pattern.matches("\\x61", "a"));
	}
}

二、获取匹配

1. (pattern)表示匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，要匹配圆括号字符，请使用“\(”或“\)”。
   

   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
   public class Test {
   
   	public static void main(String[] args) {
   		Pattern pattern = Pattern.compile("Hello (\\w+)(\\W+)");
   		Matcher matcher = pattern.matcher("Hello world!");
   		matcher.find();
   		System.out.println(matcher.group(1));
   		System.out.println(matcher.group(2));
   	}
   }
   

   
   上面例子，第1个括号匹配到任意单词字符，匹配到"world“，第2个括号匹配任意非单词字符，匹配到"!"。
   如果要匹配的字符串的正则表达式本身就带有括号，如上面例子匹配单词的正则表达式写成"(abc)+"，就会出现下面结果：
   

   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
   public class Test {
   
   	public static void main(String[] args) {
   		Pattern pattern = Pattern.compile("Hello ((abc)+)(\\W+)");
   		Matcher matcher = pattern.matcher("Hello abcabc!");
   		matcher.find();
   		System.out.println(matcher.group(1));
   		System.out.println(matcher.group(2));
   		System.out.println(matcher.group(3));
   	}
   }
   

   
   第1个括号匹配到abcabc，第2个括号匹配到abc，第3个括号匹配到”!"，显然第2个括号不是预期要匹配的值。这时，我们需要用(?:parttern)形式的表达式，匹配pattern但不获取匹配结果，不进行存储供以后使用。只需要把第1行代码修改成：
   Pattern pattern = Pattern.compile("Hello ((abc)+)(\\W+)");
2. 匹配中相同参数的引用 
   如果匹配后还需要对前面匹配的子字符串引用，需要用前面的"\num"表达式。
   

   import java.util.regex.Pattern;
   
   public class Test {
   
   	public static void main(String[] args) {
   		System.out.println(Pattern.matches("Hello (abc)\\1!，如果你", "Hello abcabc!"));
   	}
   }
   

   
   还有一种情况，如果你想替换匹配到的字符串，可以用$1到$9代替前面匹配到的值，例如：
   

   public class Test {
   
   	public static void main(String[] args) {
   		System.out.println("Hello, abcabc.".replaceFirst("Hello, (\\w+)", "Hi, $1"));
   	}
   }
   

   执行结果，得到"Hi, abcabc!"。

三、正向/反向预查

• 正向肯定预查：(?=pattern)表示非获取匹配，正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。
  

  public class Test {
  
  	public static void main(String[] args) {
  		System.out.println("Hello world!".replaceFirst("\\w+(?=\\s)", ""));
  	}
  }
  

  例子中，空字符前面的任意单词被替换成空，结果为" world!"。
• 正向否定预查：(?!pattern)表示非获取匹配，正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。

  public class Test {
  
  	public static void main(String[] args) {
  		System.out.println("Hello world!".replaceFirst("\\w+(?!\\s)", ""));
  	}
  }
  

  例子中非空字符前的单词被替换成空，由于+默认贪婪匹配，最后结果为"o world!"。 
• 反向肯定预查：(?<=pattern)表示非获取匹配，反向肯定预查，与正向肯定预查类似，只是方向相反。
  

  public class Test {
  
  	public static void main(String[] args) {
  		System.out.println("Hello world!".replaceFirst("(?<=\\s)\\w+", ""));
  	}
  }
  

  
  例子中空字符后面的单词被替换成空，结果为"Hello !"。
• 反向否定预查：(?<!pattern)表示非获取匹配，反向否定预查，与正向否定预查类似，只是方向相反。
  

  public class Test {
  
  	public static void main(String[] args) {
  		System.out.println("Hello world!".replaceFirst("(?<!\\s)\\w+", ""));
  	}
  }
  

  
  

四、贪婪/懒惰匹配

    一个正则表达式可以匹配多个字符串，通常它会匹配尽可能多的字符。这被称为贪婪匹配。有时，我们也需要尽可能少的匹配字符，即懒惰匹配。

我们只需要在给定的限定符（*，+，?，{n,}，{n,m}）后面加?，例如，*?，+?，??，{n,}?，{n,m}?。

五、模式匹配

• (?i)：即匹配时不区分大小写。表示匹配时不区分大小写。
• (?s)：即Singleline(单行模式)。表示更改.的含义，使它与每一个字符匹配（包括换行 符\n）。
• (?m)：即Multiline(多行模式) 。 表示更改^和$的 含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的 精确含意是:匹配\n之前的位置以及字符串结束前的位置.)
• (?x)：表示如果加上该修饰符，表达式中的空白字符将会被忽略，除非它已经被转义。

例子如下：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {

	public static void main(String[] args) {
		String str = "Nice to meet you!\nHow are you!";

		System.out.println("不区分大小定模式：");
		match(str, "(?i)[a-z]+");// 打印所有单词
		match(str, "(?-i)[a-z]+");

		System.out.println("单行模式：");
		match(str, "(?s).+");// "."匹配换行
		match(str, ".+");// 默认"."不匹配换行

		System.out.println("多行模式：");
		match(str, "(?m)^.+$");// ^,$匹配换行
		match(str, "^.+$");

		System.out.println("忽略空白字符：");
		match(str, "([a-zA-Z] )+");
		match(str, "(?x)([a-zA-Z] )+");// 正则表达式中空白字符被忽略
	}

	public static void match(String str, String repgex) {
		Pattern case_insensitive = Pattern.compile(repgex);
		Matcher matcher = case_insensitive.matcher(str);
		StringBuilder builder = new StringBuilder();
		int i = 1;
		while (matcher.find()) {
			builder.append(i).append(": ").append(matcher.group()).append('\n');
			i++;
		}
		System.out.println(builder.toString());
	}
}