1、Java 正则表达式
正则表达式是由普通字符（如英文字母）以及特殊字符（也称为元字符）组成的文字模式。该模式对文本查找时需要匹配的一个或多个字符串描述，给出一个匹配模板。它专门用于操作字符串，可以简化对字符串的复杂操作。正则表达式可以是单个字符，也可以是更复杂的模式。
Java没有内置的正则表达式类，但是我们可以导入java.util.regex包以使用正则表达式。该软件包包括以下类：
1）Pattern 类
pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
2）Matcher 类
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
3）PatternSyntaxException
PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
例如：
找出字符串中是否存在 “cjavapy”：
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
//第一个参数指示要搜索的模式，第二个参数是搜索应不区分大小写。第二个参数是可选的。
Pattern pattern = Pattern.compile("cjavapy", Pattern.CASE_INSENSITIVE);
//方法用于搜索字符串中的模式。它返回一个Matcherobject
Matcher matcher = pattern.matcher("url is www.cjavapy.com");
//如果在字符串中找到了模式，则find()方法返回true，如果找不到该模式，则返回false。
boolean matchFound = matcher.find();
if(matchFound) {
System.out.println("匹配到结果");
} else {
System.out.println("没有匹配到");
}
}
}
2、匹配标志(flag)
compile()方法中的flag更改了执行搜索的方式。 比较常用的如下：
Pattern.CASE_INSENSITIVE：在执行搜索时，字母的大小写将被忽略。
Pattern.LITERAL：模式中的特殊字符没有任何特殊含义，在执行搜索时将被视为普通字符。
Pattern.UNICODE_CASE：将它与CASE_INSENSITIVE标志一起使用，那么它会对Unicode字符进行大小写不敏感的匹配。默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。
详细介绍如下表：
标志 | 描述 |
Pattern.CANON_EQ | 当且仅当两个字符的"正规分解（canonical decomposition）" 都完全相同的情况下，才认定匹配。比如用了这个标志之后， 表达式"a\u030A"会匹配"?"。默认情况下， 不考虑"规范相等性（canonical equivalence）"。 |
Pattern.CASE_INSENSITIVE (?i) | 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。 这个标志能让表达式忽略大小写进行匹配。 要想对Unicode字符进行大小不明感的匹配， |
Pattern.COMMENTS (?x) | 在这种模式下，匹配时会忽略（正则表达式里的） 空格字符（注：不是指表达式里的"\\s"， 而是指表达式里的空格、tab、回车之类）。 注释从#开始，一直到这行结束。 可以通过嵌入式的标志来启用Unix行模式。 |
Pattern.DOTALL (?s) | 在这种模式下，表达式'.'可以匹配任意字符， 包括表示一行的结束符。 默认情况下，表达式'.'不匹配行的结束符。 （行结束符：Windows下 ，Linux下 |
Pattern.MULTILINE (?m) | 在这种模式下，'^'和'$'分别 一行一行地 匹配一行的开始和结束。此外，'^'仍然匹配一行字符串的开始， '$'也匹配一行字符串的结束。默认情况下， 这两个表达式仅仅匹配字符串的开始和结束。 |
Pattern.UNICODE_CASE (?u) | 在这个模式下，如果你还启用了CASE_INSENSITIVE标志， 那么它会对Unicode字符进行大小写不明感的匹配。 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。 |
Pattern.UNIX_LINES (?d) | 在这个模式下，只有'\n'才被认作一行的中止， 并且与'.'，'^'，以及'$'进行匹配。 |
3、正则表达式pattern
Pattern.compile()方法的第一个参数是pattern。它描述了要搜索的内容。
方括号用于查找字符范围：
表达式 | 描述 |
[abc] | 从方括号之间的选项中找到一个字符 |
[^abc] | 在括号之间找不到一个字符 |
[0-9] | 在0到9的范围内找到一个字符 |
4、元字符
元字符是具有特殊含义的字符：
字符 | 描述 |
\ | 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。 例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。 |
^ | 匹配输入字符串的开始位置。 如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。 |
$ | 匹配输入字符串的结束位置。 如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。 |
* | 匹配前面的子表达式零次或多次。 例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。 |
+ | 匹配前面的子表达式一次或多次。 例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。 |
? | 匹配前面的子表达式零次或一次。 例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。 |
{n} | n 是一个非负整数。匹配确定的 n 次。 例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。 |
{n,} | n 是一个非负整数。至少匹配n 次。 例如，'o{2,}' 不能匹配 "Bob" 中的 'o'， 但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。 |
{n,m} | m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。 例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。 请注意在逗号和两个数之间不能有空格。 |
? | 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时， 匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串， 而默认的贪婪模式则尽可能多的匹配所搜索的字符串。 例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。 |
. | 匹配除换行符（\n、\r）之外的任何单个字符。 要匹配包括 '\n' 在内的任何字符，请使用像"(.|\n)"的模式。 |
(pattern) | 匹配 pattern 并获取这一匹配。 所获取的匹配可以从产生的 Matches 集合得到， 在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。 要匹配圆括号字符，请使用 '\(' 或 '\)'。 |
(?:pattern) | 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配， 不进行存储供以后使用。 这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。 例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。 |
(?=pattern) | 正向肯定预查（look ahead positive assert）， 在任何匹配pattern的字符串开始处匹配查找字符串。 这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。 例如，"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"， 但不能匹配"Windows3.1"中的"Windows"。 预查不消耗字符，也就是说，在一个匹配发生后， 在最后一次匹配之后立即开始下一次匹配的搜索， 而不是从包含预查的字符之后开始。 |
(?!pattern) | 正向否定预查(negative assert)， 在任何不匹配pattern的字符串开始处匹配查找字符串。 这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。 例如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"， 但不能匹配"Windows2000"中的"Windows"。 预查不消耗字符，也就是说，在一个匹配发生后， 在最后一次匹配之后立即开始下一次匹配的搜索， 而不是从包含预查的字符之后开始。 |
(?<=pattern) | 反向(look behind)肯定预查，与正向肯定预查类似， 只是方向相反。例如，" (?<=95|98|NT|2000)Windows "能匹配" 2000Windows "中的" Windows "，但不能匹配" 3.1Windows "中的" Windows "。 |
(?<!pattern) | 反向否定预查，与正向否定预查类似，只是方向相反。例如" (?<!95|98|NT|2000)Windows "能匹配" 3.1Windows "中的" Windows "，但不能匹配" 2000Windows "中的" Windows "。 |
x|y | 匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。 '(z|f)ood' 则匹配 "zood" 或 "food"。 |
[xyz] | 字符集合。匹配所包含的任意一个字符。 例如， '[abc]' 可以匹配 "plain" 中的 'a'。 |
[^xyz] | 负值字符集合。匹配未包含的任意字符。 例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。 |
[a-z] | 字符范围。匹配指定范围内的任意字符。 例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。 |
[^a-z] | 负值字符范围。匹配任何不在指定范围内的任意字符。 例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。 |
\b | 匹配一个单词边界，也就是指单词和空格间的位置。 例如， 'er\b' 可以匹配"never" 中的 'er'， 但不能匹配 "verb" 中的 'er'。 |
\B | 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'， 但不能匹配 "never" 中的 'er'。 |
\cx | 匹配由 x 指明的控制字符。 例如， \cM 匹配一个 Control-M 或回车符。 x 的值必须为 A-Z 或 a-z 之一。 否则，将 c 视为一个原义的 'c' 字符。 |
\d | 匹配一个数字字符。等价于 [0-9]。 |
\D | 匹配一个非数字字符。等价于 [^0-9]。 |
\f | 匹配一个换页符。等价于 \x0c 和 \cL。 |
\n | 匹配一个换行符。等价于 \x0a 和 \cJ。 |
\r | 匹配一个回车符。等价于 \x0d 和 \cM。 |
\s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 |
\S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
\t | 匹配一个制表符。等价于 \x09 和 \cI。 |
\v | 匹配一个垂直制表符。等价于 \x0b 和 \cK。 |
\w | 匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。 |
\W | 匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。 |
\xn | 匹配 n，其中 n 为十六进制转义值。 十六进制转义值必须为确定的两个数字长。 例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。 正则表达式中可以使用 ASCII 编码。 |
\num | 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。 例如，'(.)\1' 匹配两个连续的相同字符。 |
\n | 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式， 则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。 |
\nm | 标识一个八进制转义值或一个向后引用。 如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。 如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。 如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。 |
\nml | 如果 n 为八进制数字 (0-3)， 且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。 |
\un | 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。 例如， \u00A9 匹配版权符号 (?)。 |
5、量词
{m,n}是通用形式的量词，正则表达式还有三个常用量词，分别是+、?、*。它们的形态虽然不同于{m,n}，功能却是相同的（也可以把它们理解为“量词简记法”）：
常用量词 | {m,n}等价形式 | 说明 |
* | {0,} | 可能出现，也可能不出现，出现次数没有上限 |
+ | {1,} | 至少出现1次，出现次数没有上限 |
? | {0,1} | 至多出现1次，也可能不出现 |
使用示例如下表：
量词 | 描述 |
n+ | 匹配任何包含至少一个n的字符串 |
n* | 匹配包含零个或多个n的任何字符串 |
n? | 匹配任何包含零或一个n的字符串 |
n{x} | 匹配包含x个n的任何字符串 |
n{x,y} | 匹配任何包含x到y个n的字符串 |
n{x,} | 匹配任何包含至少x个n的字符串 |
注意：如果表达式需要搜索特殊字符之一，则可以使用反斜杠（\）进行转义。在Java中，字符串中的反斜杠需要自己转义，因此需要两个反斜杠转义特殊字符。例如，要搜索一个或多个问号，可以使用以下表达式：" \\? "。
6、Matcher 类的方法
1）索引方法
索引方法提供了有用的索引值，精确表明输入字符串中在哪能找到匹配：
序号 | 方法及说明 |
1 | public int start() 返回以前匹配的初始索引。 |
2 | public int start(int group) 返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引 |
3 | public int end() 返回最后匹配字符之后的偏移量。 |
4 | public int end(int group) 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。 |
2）查找方法
查找方法用来检查输入字符串并返回一个布尔值，表示是否找到该模式：
序号 | 方法及说明 |
1 | public boolean lookingAt() 尝试将从区域开头开始的输入序列与该模式匹配。 |
2 | public boolean find() 尝试查找与该模式匹配的输入序列的下一个子序列。 |
3 | public boolean find(int start ） 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。 |
4 | public boolean matches() 尝试将整个区域与模式匹配。 |
3）替换方法
替换方法是替换输入字符串里文本的方法：
序号 | 方法及说明 |
1 | public Matcher appendReplacement(StringBuffer sb, String replacement) 实现非终端添加和替换步骤。 |
2 | public StringBuffer appendTail(StringBuffer sb) 实现终端添加和替换步骤。 |
3 | public String replaceAll(String replacement) 替换模式与给定替换字符串相匹配的输入序列的每个子序列。 |
4 | public String replaceFirst(String replacement) 替换模式与给定替换字符串匹配的输入序列的第一个子序列。 |
5 | public static String quoteReplacement(String s) 返回指定字符串的字面替换字符串。这个方法返回一个字符串，就像传递给Matcher类的appendReplacement 方法一个字面字符串一样工作。 |
7、匹配模式
1) Greediness（贪婪匹配）
x?、x*、x+、x{n，} 是最大匹配。在 Greediness 的模式下，会尽量大范围的匹配，直到匹配了整个内容，这时发现匹配不能成功时，开始回退缩小匹配范围，直到匹配成功。
例如，
String test = "c<div>python</div>java";
String reg = "<.+>";
System.out.println(test.replaceAll(reg, "***"));
2) Reluctant(Laziness)（非贪婪匹配）
x??、x*?、x+?、x{n，}? 是最小匹配，其实x{n，m}?和x{n }?有些多余。在 Greediness 模式之后添加 ? 就是最小匹配。
在 Reluctant 的模式下，只要匹配成功，就不再继续尝试匹配更大范围的内容
例如，
String test = "c<div>python</div>java";
String reg = "<.+?>";
System.out.println(test.replaceAll(reg, "***"));
3）Possessive(占用匹配)
x?+、x*+、x++、x{n，}+ 是完全匹配，在 Greediness 模式之后添加 + 就成完全匹配。
Possessive 模式与 Greediness 有一定的相似性，那就是都尽量匹配最大范围的内容，直到内容结束，但与 Greediness 不同的是，完全匹配不再回退尝试匹配更小的范围。
String test = "c<div>python</div>java";
String reg = "<.++>";
String reg1 = "<.++";
String reg2 = ".++>";
System.out.println(test.replaceAll(reg, "***"));
System.out.println(test.replaceAll(reg1, "***"));
System.out.println(test.replaceAll(reg2, "***"));
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Demo {
private static final String REGEX = "<.++";
//private static final String REGEX = "<.++>";
//private static final String REGEX = ".++>";
private static final String INPUT = "c<div>python</div>java";
public static void main(String[] args) {
Pattern pattern = Pattern.compile(REGEX);
Matcher matcher = pattern.matcher(INPUT);
while(matcher.find()) {
System.out.println("Match String start(): "+matcher.start());
}
}
}