字符串处理利器-正则表达式

一、常见的符号的介绍

1.1 预定义字符类

符号	说明
.	任何字符（与行结束符可能匹配也可能不匹配）
d	数字：[0-9]
D	非数字： [^0-9]
s	空白字符：[ x0Bf ]
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	非单词边界
A	输入的开头
G	上一个匹配的结尾
	输入的结尾，仅用于最后的结束符（如果有的话）
z	输入的结尾

1.4 其他常见符号

[]的使用--或	说明
[]	匹配括号中的任何一个字符
[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(" 

	".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(" 
".matches("^[\s&&[^
]]*\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);
	}
	
}