Java规则表达式

规则表示式的使用

可以参考 java.util.regex.Pattern

1、字面意义字符

字母或数字         比较字母或数字
\\                      比较\
\0n                   八进制0n字符(0<= n>= 7 )
\0n                   八进制0nn字符(0<= n>= 7 )
\0mnn              八进制0mnn字符(0<= n>= 7, 0<= m <=3 )
\xhh                 十六进制0xhh字符
\uhhhh             十六进制0xhhh字符
\x{h...h}             十六进制0xh...h字符
\t                      Tab(\u0009)
\n                      换行(\u000A)
\r                       返回(\u000D)
\f                       换页(\u000C)
\a                      响铃(\u0007)
\e                      ESC(\u001B)
\cx                    控制字符x

一些特殊符号
! $ ^ * ( ) + = { } [ ] | \ : . ? 等

2、字符类
[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]]         a到z而且是d、e、f的任一字符，等于[def]
[a-z&&[^bc]]        a到z而且不是b或c的任一字符，等于[ad-z]
[a-z&&[^m-p]]     a到z而且不是m到p的任一字符，等于[a-lq-z]
预定义字符
.                           任一字符
\d                        比较任一数字，即[0-9]
\D                        比较任一非数字字符，即[^0-9]
\s                         比较任一空格字符，即[\t\n\x0B\f\r]
\S                        比较任一非空格字符，即[^\s]
\w                       比较任一ASCLL字符，即[a-zA-Z0-9]
\W                      比较任一非ASCLL字符，即[^\w]   

3、贪婪、逐步、独吞量词
贪婪量词
X?                    X项目出现一次或没有
X*                    X项目出现零次或多次
X+                   X项目出现一次或多次
X{n}                 X项目出现n次
X{n,}                X项目至少出现n次
X{n,m}             X项目出现n次但不超过m次

贪婪量词：当比较器看到贪婪量词的时候，比较量词会把剩余的文字整个吃掉，再逐步吐出文字，
				看看是否符合量词后的规则表达式。如果吐出部分符合，而能吃下部分也符合贪婪
				量词就比较成功，结果就是贪婪量词会尽可能的找出长度最长的符合文字。
逐步量词：在贪婪量词表示法后面加上？，就成为了逐步量词，比较器看到逐步量词时，会一边
				吃掉剩余的文字，一边看看吃下的文字是否符合规则表达式。
独吞量词：在贪婪量词后面加上+，就成为了独吞量词，比较器看到独吞量词时，会先将剩余的文
				字吃掉，然后看看独吞量词部分是否符合吃下的文字，如果符合就不会再吐出来了。

以xfooxxxxxxfoo为例
规则表示式           符合的结果
.*                         xfooxxxxxxfoo
.*?                       xfoo和xxxxxxfoo
.*+                      无

4、边界比较(\b标注边界)
如：\bdog\b  则以dog这个单词为分割
常用的一些比较
^                                     一行开头
$                                      一行结尾
\b                                    单词边界
\B                                    非单词边界
\A                                    输入开头
\G                                    前一个符合项目结尾
\Z                                    非最后终端机的输入结尾
\z                                    输入结尾

5、分组与参考
例如邮箱：  ^[a-zA-Z]+\d*@([a-zA-Z0-9]+\.)+com
回头参考：规则表达式 ((A)(B(C)))有四个分组(按左括号的个数来分)
1、( (A) ( B (C) ) )
2、(A)
3、(B ( C) )
4、(C)
例：\d\d要比较两个数字，(\d\d)\1则是要比较四个数字，1212会符合，而1234则不符合.
例：["'][^"']*["']两边的部分为单引号或双引号，但并没有说如果前面的是单引号后面的就必须是
	  单引号 。
	  (["']) ["']*\1则两边的符号必须一致
 
 另外比较重要的两个实例
 java.util.regex.Pattern
 java.util.regex.Matcher

例子：

package useGuiZeBiaoDaShi;

public class useGuiZeBiaoDaShi {
	static String[] token = null;
	static String strings;
	
	public static void main(String [] args){
		//根据逗号切割
		useGuiZeBiaoDaShi u = new useGuiZeBiaoDaShi();
		strings = "Sun,Fei,Long";
		System.out.println("根据逗号分隔"+strings);
		token = strings.split(",");
		u.outPut(token);
		//根据Tab分割
		strings = "Sun\tFei\tLong";
		System.out.println("根据\\t分隔"+strings);
		token = strings.split("\\t");
		u.outPut(token);
		//根据+分割
		strings = "Sun+Fei+Long";
		System.out.println("根据+分隔"+strings);
		token = strings.split("\\+");
		u.outPut(token);
		//根据||分割
		strings = "Sun||Fei||Long";
		System.out.println("根据||分隔"+strings);
		token = strings.split("\\|\\|");
		u.outPut(token);
		//根据\分割
		strings = "Sun\\Fei\\Long";
		System.out.println("根据\\分隔"+strings);
		token = strings.split("\\\\");
		u.outPut(token);
		
		
		//测试字符类
		//格局ab分割
		strings = "SunabFeiabLong";
		System.out.println("根据ab分隔"+strings);
		token = strings.split("[a][b]");
		u.outPut(token);
		//根据汉字分割，可以用来验证字符串是否包含汉字
		strings = "Sun孙Fei飞Long";
		System.out.println("根据汉字分隔"+strings);
		token = strings.split("\\W");
		System.out.println(token.length);
		if(token.length > 1){
			System.out.println("包含汉字");
		}
		u.outPut(token);
		
		
		
		//贪婪，逐步，独吞量词
		String [] regexs = {".*foo",".*?foo",".*+foo"};
		for(String regex: regexs){
			System.out.println("xfooxxxxxxfoo".replaceAll(regex, "Orz"));
		}
		
		//日期的格式验证
		//---/d/d/d/d-/d/d/d/d/d/d
		String date = "1111-111111";
		System.out.println("根据/d/d/d/d-/d/d/d/d/d/d分割"+date);
		token = date.split("\\d{4}-\\d{6}");
		System.out.println(token.length);
		if(token.length != 0){
			u.outPut(token);
		}
		else{
			System.out.println("符合格式！");
		}
		

	}//end main
	
	
	//输出分割后的字符
	public void outPut(String [] token){
		for(String s: token){
			System.out.println(s);
		}
	}//end ourPut
	
}