java*正则表达式
java*正则表达式
月生无界 发表于1年前
java*正则表达式
  • 发表于 1年前
  • 阅读 25
  • 收藏 0
  • 点赞 0
  • 评论 0

腾讯云 技术升级10大核心产品年终让利>>>   

       传送门: http://wenku.baidu.com/view/ce3cc7520066f5335b812164.html 

  1. 正则表达式的主要作用

    • 匹配输入或者获取的字符是否符合某种固定的规则格式
    • 做字符处理的时候,根据定义的规则替换掉固定要替换的字符,达到自己想要的字
  2. 正则表达式基础

    1. Java的Pattern类和Matcher

      • java.util.regex.Pattern   模式类:一个正则表达式经编译后的表现模式,用来表示一个编译过的正则表达式。
      • java.util.regex.Matcher  匹配类:用模式匹配一个字符串所表达的抽象结果。一个Matcher对象是一个状态机器,它依据Pattern对象作为匹配模式对字符串展开匹配检查。
    2. 代码例子

      • package test;
        
        import java.util.regex.Matcher;
        import java.util.regex.Pattern;
        
        public class Test {
        	
        	//正则式是最简单的能准确匹配一个给定String的模式,模式与要匹配的文本是等价的。静态的Pattern.matches方法用于比较一个String是否匹配一个给定模式
        	private static String data1 = "java";
        	public static void test1(){
        		boolean r = Pattern.matches("java", data1);
        		System.out.println(r);
        	}
        	
        	//该模式表示一个字符串必须以m开始,以n结束,中间o的次数可以出现一次或多次,()括号表示里面可匹配多个字符,+表示这个字符可出现一次或多次
        	private static String reg1 = "m(o+)n";
        	private static String[] data2 = {"moon","moooono","mon","moon","mono"};//除了数组最后一个不能匹配,其它都能
        	public static void test2(){
        		for(String arr : data2){
        			boolean r = Pattern.matches(reg1, arr);
        			if(r){
        				System.out.println("成功:" + arr + " 匹配 " + reg1);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg1);
        			}
        		}	
        	}
        	
        	//该模式表示一个字符串必须以b开始,以n结束,中间出现[]中的任意一个字符值,则匹配,[]表示里面允许单个字符,|表示或的意思
        	private static String reg2 = "b[a|e|i|o|u]n";
        	private static String[] data3 = {"ban","ben","bin","bon","bun","byn","baen"};//数组最后两个不能匹配
        	public static void test3(){
        		for(String arr : data3){
        			boolean r = Pattern.matches(reg2, arr);
        			if(r){
        				System.out.println("成功:" + arr + " 匹配 " + reg2);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg2);
        			}
        		}	
        	}
        	
        	//该模式表示一个字符串必须以b开始,以n结束,且中间出现()中的任一字符串,则匹配,()表示组,|表示或
        	private static String reg3 = "b(ee|ea|oo)n";
        	private static String[] data4 = {"been","bean","boon","buin","bynn"};//数组最后两个不能匹配
        	public static void test4(){
        		for(String arr : data4){
        			boolean r = Pattern.matches(reg3, arr);
        			if(r){
        				System.out.println("成功:" + arr + " 匹配 " + reg3);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg3);
        			}
        		}	
        	}
        	
        	//\d表示数字[0-9],java中使用,在前面加上\当作转义符,表示该字符串必须是纯数组才能匹配
        	private static String reg4 = "\\d+";
        	private static String[] data5 =	{"1","10","101","1010","100+"};//数组最后一个不能匹配
        	public static void test5(){
        		for(String arr : data5){
        			boolean r = Pattern.matches(reg4, arr);
        			if(r){
        				System.out.println("成功:" + arr + " 匹配 " + reg4);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg4);
        			}
        		}	
        	}
        	
        	//\w表示单字符[A-Z a-z 0-9],表示以单字符开始,以数字结尾的字符串
        	private static String reg5 = "\\w+\\d+";
        	private static String[] data6 = {"a100","b20","c30","df10000","gh0t"};//最后一个不匹配
        	public static void test6(){
        		for(String arr : data6){
        			boolean r = Pattern.matches(reg5, arr);
        			if(r){
        				System.out.println("成功:" + arr + " 匹配 " + reg5);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg5);
        			}
        		}	
        	}
        	
        	//表示",","\\s"(空格),";"都能匹配,可用于截取字符串
        	private static String reg6 = "[,\\s;]";
        	private static String data7 = "薪水,职位 姓名;年龄 性别";//经过截取成字符串数组String[] str = {"薪水","职位","姓名","年龄","性别"};
        	public static void test7(){
        		String[] dataArr = data7.split(reg6);
        		for(String arr : dataArr){
        			System.out.println(arr);
        		}	
        	}
        	
        	//同上
        	private static String reg7 = "[年月日]";
        	private static String data8 =	"2016年12月11日";
        	public static void test8(){
        		Pattern p = Pattern.compile(reg7);
        		String[] dataArr = p.split(data8);
        		for(String arr : dataArr){
        			System.out.println(arr);
        		}	
        	}
        	
        	//前一个表示将字符串分组匹配,一个()表示一组,后一个表示$1表示第一组不变,第二组替换成¥
        	private static String reg8 = "(\\d+)(元|人民币|RMB)";
        	private static String reg9 = "$1¥";
        	private static String data9 = "10元 1000人民币 10000元 1000000RMB";//"结果10¥ 1000¥ 10000¥ 100000¥"
        	public static void test9(){
        		String data = data9.replaceAll(reg8, reg9);
        		System.out.println(data);
        	}
        	
        	public static void test10(){
        		Pattern p = Pattern.compile(reg1, Pattern.CASE_INSENSITIVE);
        		//用Pattern类的matcher()方法生成一个Matcher对象 
        		Matcher m = p.matcher("moon mooon Mon mooooon Mooon");
        		StringBuffer sb = new StringBuffer();
        		// 使用find()方法查找第一个匹配的对象 
        		boolean r = m.find();
        		// 使用循环找出模式匹配的内容替换之,再将内容加到sb里 
        		while(r){
        			// appendReplacement(StringBuffer sb,String replacement) 实现非终端添加和替换步骤
        			m.appendReplacement(sb, "moon");
        			r = m.find();
        		}
        		// 最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里;
        		m.appendTail(sb);
        		System.out.println(sb.toString());
        	}
        	
        	//表示某一个字符串中间允许出现几个相同的字符{2,5}表示o可以出现2到5个都可匹配
        	private static String reg10 = "g(o{2,10})gle";
        	private static String[] data11 = {"google","gooogle","gooooogel","goooooogle","ggle"};//最后一个不匹配
        	public static void test11(){
        		for(String arr : data11){
        			boolean r = Pattern.matches(reg10, arr);
        			if(r){
        				System.out.println("成功:" + arr + " 匹配 " + reg10);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg10);
        			}
        		}
        	}
        	
        	//" 匹配 "表示范围内,a-c表示abcde
        	static String reg11 = "T[a-e]n";
        	static String[] data12 = {"Tan","Tbn","Tcn","Ton","Twn"};
        	static void test12(){
        		for(String arr : data12){
        			boolean r = Pattern.matches(reg11, arr);
        			if(r){
        				System.out.println("成功:" + arr + " 匹配 " + reg11);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg11);
        			}
        		}
        	}
        	
        	//不区分大小写匹配
        	static String reg12 = "ab";
        	static String[] data13 = {"ab","Ab","AB"};
        	static void test13(){
        		Pattern p = Pattern.compile(reg12, Pattern.CASE_INSENSITIVE);
        		for(String arr : data13){
        			Matcher m = p.matcher(arr);
        			if(m.find()){
        				System.out.println("成功:" + arr + " 匹配 " + reg12);
        			}else{
        				System.out.println("失败:" + arr + " 匹配 " + reg12);
        			}
        		}
        	}
        	
        	//使用正则表达式劈分字符串,\\s空格,*出现0次或多次,+出现一次或多次,?出现0次或1次
        	static String reg13 = "(\\s*,\\s*)|(\\s*;\\s*)|(\\s+)";
        	static String data14 = "职务=GM 薪水=50000 ,  姓名=职业经理   性别=男 年龄=45 ";
        	static void test14(){
        		Pattern p = Pattern.compile(reg13);
        		String[] data = p.split(data14);
        		for(String arr : data){
        			System.out.println(arr);
        		}
        	}
        	
        	//解析正则表达式中的文字,\1对应第一个小括号括起来的group1
        	static String reg14 = "<(\\w+)>(\\w+)</\\1>";
        	static String data15 = "<name>Bill</name><salary>50000</salary><title>GM</title>";
        	static void test15(){
        		Pattern p = Pattern.compile(reg14);
        		Matcher m = p.matcher(data15);
        		while(m.find()){
        			System.out.println(m.group(1)+":"+m.group(2));
        		}
        	}
        	
        	//将单词数字混合的字符串的单词部分大写
        	static String reg15 = "([a-zA-Z]+[0-9]+)";
        	static String data16 = "age45 salary500000 50000 title";
        	static void test16(){
        		Pattern p = Pattern.compile(reg15);
        		Matcher m = p.matcher(data16);
        		StringBuffer sb = new StringBuffer();
        		while(m.find()){
        			String r = m.group(1).toUpperCase();
        			m.appendReplacement(sb, r);
        		}
        		m.appendTail(sb);
        		System.out.println(sb.toString());
        	}
        	
        	public static void main(String[] args) {
        //		test1();
        //		test2();
        //		test3();
        //		test4();
        //		test5();
        //		test6();
        //		test7();
        //		test8();
        //		test9();
        //		test10();
        //		test11();
        //		test12();
        //		test13();
        //		test14();
        //		test15();
        		test16();
        	} 
        }
        
  3. 正则符号列表

正则符号

名字 正则表达式 例子 注解
句点符号 t.n tan,t#n,t n 该通配符表示匹配所有单个字符,包括空格等字符,如例子,只要符合前后是t和n的字符都能匹配
方括号符号 t[aeio]n tan,ten,tin,ton 解决句点符号匹配太广泛问题,表示t与n之间只有方括号内指定的字符,才可以匹配,同时,方括号内只能匹配单个字符
“或”符号 t(a|e|i|oo)n tan,ten,tin,toon 或符合解决方括号只能匹配单个字符的问题,通过“|”来表示t与n之间能出现的所有可匹配字符,由于不能使用匹配单个字符的方括号,这里使用圆括号“()”,表示中间可以匹配多个字符
匹配次数符号
符号 次数
* 0次或者 多次
+ 1次或者多次
0次或者1次
{n} 恰好n次
{n,m} 从n次到m次

 

正则表达式 例子
  t(a*)n tn,tan,taan
t(a+)n tan,taan
[0-9]{3} \-? [0-9]{2} 159-49 或 94229
[0-9]{3} \- [0-9]{2} 479-989
[0-9]{3,5} 919,9927,97029

第一个正则表达式表示a可以出现,可以不出现,出现次数不限定

第二个表示a必须出现,出现次数不限定

第三个由于连字符“-”有特殊意义,表示一个范围,所以前面要加转义符“\”,表示“-”可出现一次或者不出现

第四个大括号里面表示出现几次,前面的[0-9]表示从1到9

第五个表示最少3位数,最多5位数

否字符 [^t]an aan,ban,... 表示第一个字符不能是t
圆括号 ([0-9]+)([a-z]+) 1q,11q,2fg,... 圆括号表示分组,一个圆括号表示一组,可匹配前部分是数字,后部分是字符的所有字符,分成两组匹配
空白符号 a\s+b a b,a  b \s表示空白符号,该正则表达式表示中间可以出现一个或者多个空白符号
常用符号
 符号  等价的正则表达式
\d [0-9]
\D [^0-9]
\w [0-9A-Za-z]
\W [^ 0-9A-Za-z ]
\s [\t\n\r\f]
\S [^\t\n\r\f]
懒得写
注释
纯数字
非数字
单字字符
非单字字符
空白(空格符、换号符、回车符、制表符)
  1. 非空白符
共有 人打赏支持
粉丝 10
博文 14
码字总数 27687
×
月生无界
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: