正则表达式
一、常见的符号的介绍
1.1 预定义字符类
| 符号 | 说明 |
|---|---|
| . | 任何字符（与行结束符可能匹配也可能不匹配） |
| \d | 数字：[0-9] |
| \D | 非数字： [^0-9] |
| \s | 空白字符：[ \t\n\x0B\f\r] |
| \S | 非空白字符：[^\s] |
| \w | 单词字符：[a-zA-Z_0-9] |
| \W | 非单词字符：[^\w] |
| **** | 转义字符，比如"\"匹配"" ,"{"匹配"{"。 |
1.2 数量词
| 符号 | 说明 |
|---|---|
| * | 等价于｛0，｝ 匹配0至多个在它之前的字符。例如正则表达式“zo”能匹配“z”以及“zoo”；正则表达式“.”意味着能够匹配任意字符串。 |
| + | 等价于｛1，｝ 匹配前面的子表达式一次或多次。例如正则表达式9+匹配9、99、999等。 |
| ? | 等价于｛0，1｝ 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。此元字符还有另外一个用途，就是表示非贪婪模式匹配，后边将有介绍 |
| {n} | 匹配确定的 n 次。例如，“e{2}”不能匹配“bed”中的“d”，但是能匹配“seed”中的两个“e”。 |
| {n,} | 至少匹配n次。例如，“e{2,}”不能匹配“bed”中的“e”，但能匹配“seeeeeeeed”中的所有“e”。 |
| {n,m} | 最少匹配 n 次且最多匹配 m 次。“e{1,3}”将匹配“seeeeeeeed”中的前三个“e”。 |
1.3 边界匹配符号
| 符号 | 说明 |
|---|---|
| ^ | 行的开头 |
| $ | 行的结尾 |
| \b | 单词边界 |
| \B | 非单词边界 |
| \A | 输入的开头 |
| \G | 上一个匹配的结尾 |
| \Z | 输入的结尾，仅用于最后的结束符（如果有的话） |
| \z | 输入的结尾 |
1.3 其他常见符号
| []的使用--或 | 说明 |
|---|---|
| [] | 匹配括号中的任何一个字符 |
| [abc] | a、b 或 c（简单类） |
| [^abc] | 任何字符，除了 a、b 或 c（否定） |
| [a-zA-Z] | a 到 z 或 A 到 Z，两头的字母包括在内（范围） |
| [a-d[m-p]] | a 到 d 或 m 到 p：[a-dm-p]（并集） |
| [a-z&&[def]] | d、e 或 f（交集） |
| [a-z&&[^bc]] | a 到 z，除了 b 和 c：[ad-z]（减去） |
| [a-z&&[^m-p]] | a 到 z，而非 m 到 p：[a-lq-z]（减去） |
| （）的使用 -- 组` | |
| （） | 将 () 之间括起来的表达式定义为“组”(group)，并且将匹配这个表达式的字符保存到一个临时区域,这个元字符在字符串提取的时候非常有用。捕获组可以通过从左到右计算其开括号来编号。 |
| (\d) | 第一组 |
| ((A)(B(C))) | 第一组 ((A)(B(C))) 第二组 (A) 第三组(B(C)) 第四组(C) |
二.正则表达式的示例
public class Test {
public static void main(String[] args){
//简单认知正则表达式的概念
p("abc".matches("..."));
p("a8729a".replaceAll("\\d", "-"));
Pattern p = Pattern.compile("[a-z]{3}");
Matcher m = p.matcher("fgh");
p(m.matches());
p("fgha".matches("[a-z]{3}"));
//初步认识 . * + ?
p("----------------初步认识-----------------");
p("a".matches("."));//true
p("aa".matches("aa"));//true
p("aaaa".matches("a*"));//true
p("aaaa".matches("a+"));//true
p("".matches("a*"));//true
p("aaaa".matches("a?"));//false
p("".matches("a?"));//true
p("213442142342".matches("\\d{3,100}"));//true
p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));//false
p("192".matches("[0-2][0-9][0-9]"));
//范围
p("-------------范围------------");
p("a".matches("[abc]"));//true
p("a".matches("[^abc]"));//false
p("A".matches("[a-zA-Z]"));//true
p("A".matches("[a-z]|[A-Z]"));//true
p("A".matches("[a-z[A-Z]]"));//true
p("R".matches("[A-Z&&[RFG]]"));//true
//认识 \s \w \d
/**在正则表达式里两个\\会被当成一个反斜杠 **/
p("认识 \\s\\w\\d");
p(" \n\r\t".matches("\\s{4}"));
p(" ".matches("/S"));
p("a_8".matches("\\w{3}"));
p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));
p("\\".matches("\\\\"));
//boundary
p("-----------------boundary-----------------");
p("hello sir".matches("^h.*"));
p("hello sir".matches(".*ir$"));
p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));
p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
//white line
p(" \n".matches("^[\\s&&[^\n]]*\\n$"));
//email
p("----------------email--------------");
p("askhfdakh@asfhka.com".matches("[\\w[.-]]+@[\\w[.-]]+\\.\\w+"));
//matches find lookingAt
p("------matches find lookingAt");
Pattern p1 = Pattern.compile("\\d{3,5}");
String s = "123-2345-234-00";
Matcher m1 = p1.matcher(s);
p(m1.matches());
m1.reset();
p(m1.find());
//找的到 才会返回 start 起始位置 和 终止位置 找不到则报错
p(m1.start() + "-" + m1.end());
p(m1.find());
p(m1.start() + "-" + m1.end());
p(m1.find());
p(m1.start() + "-" + m1.end());
p(m1.find());
p(m1.lookingAt());
//replacement
p("----------------replacement----------------");
Pattern p3 = Pattern.compile("java",Pattern.CASE_INSENSITIVE);
Matcher matcher3 = p3.matcher("java JaVa ashfaks JAVA iloveJAva youhatejAVA DAFAD");
//p(matcher3.replaceAll("JAVA"));
StringBuffer buf = new StringBuffer();
int i = 1;
while(matcher3.find()){
if(i % 2 == 0){
matcher3.appendReplacement(buf, "java");
}else{
matcher3.appendReplacement(buf, "JAVA");
}
i++;
}
matcher3.appendTail(buf);
p(buf);
//group
p("--------------group------------");
Pattern gp = Pattern.compile("(\\d{3,5})([a-z]{2})");
String str = "123aa-34345bb-234cc-00";
Matcher gm = gp.matcher(str);
while(gm.find()){
p(gm.group());
}
}
public static void p(Object o){
System.out.println(o);
}
}