正则表达式

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.sun.xml.internal.ws.api.streaming.XMLStreamWriterFactory.Zephyr;


public class demo01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//matches()判断字符串是否匹配某个表达式，“.”表示任何一个字符
		p("abc".matches("..."));
		//将字符串“a2389a”中的数字用*替换，d表示"0-9"数字
		p("a2389a".replaceAll("d","*"));
		//将任何是a--z的字符串长度为3的字符串进行编译，这样可以加快匹配速度
		Pattern p=Pattern.compile("[a-z]{4}");
		//进行匹配，并将匹配结果放在Matcher对象中
		Matcher m=p.matcher("lkjh");
		p(m.matches());
		//上面的是三行代码可以用下面一行很代码代替
		p("abc".matches("[a-z]{3}"));
		
		/***
		 * 
		 *   .              任何字符

			 a?             a一次或一次也没有
			
			 a*             a零次或多次
			
			 a+            a一次或多次
			
			 a{n}?      a恰好 n 次
			
			 a{n,}?       a至少n次 
			
			 a{n,m}?   a至少n次，但是不超过m次
		 */
		
		//初步认识. * + ?
		p("判断.："+"a".matches("."));
		p("判断aa:"+"aa".matches("aa"));
		p("判断a*:"+"aaaa".matches("a*"));
		p("判断a+:"+"aaaa".matches("a+"));
		p("判断a*:"+"".matches("a*"));
		p("判断a?:"+"aaaa".matches("a?"));
		p("判断a?:"+"".matches("a?"));
		p("判断a?:"+"a".matches("a?"));
		p("判断{n}"+"139".matches("d{3,5}"));
		//   .是一个点
		p("判断IP:"+"192.168.0.a".matches("d{1,3}.d{1,3}.[a-z]"));
		p("判断192:"+"192".matches("[0-2][0-9][0-9]"));
		
		
		/***
		 * 
		 * 	[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]（减去）
		 * 
		 */
		p("判断[abc]:"+"a".matches("[abc]"));
		p("判断[^abc]:"+"a".matches("[^abc]")+"-----e.matches:"+"e".matches("[^abc]"));
		p("判断[a-zA-Z]:"+"A".matches("[a-zA-Z]")+"------0.matches:"+"0".matches("[a-zA-Z]"));
		p("判断[a-z|A-Z]:"+"A".matches("[a-z|A-Z]")); //觉得跟上面没有区别
		p("判断[a-z[A-Z]]:"+"H".matches("[a-z[A-Z]]"));
		p("判断[a-z&&[def]]:"+"d".matches("[a-z&&[def]]")+"h------"+"h".matches("[a-z&&[def]]")+"--h------"+"h".matches("[a-z&&[deh]]"));
		p("判断[a-z&&[^hjk]]:"+"d".matches("[a-z&&[^hjk]]")+"------h:"+"h".matches("[a-z&&[^hjk]]")); //不带&&的意思是或
		p("判断[a-z&&[^a-h]]:"+"l".matches("[a-z&&[^a-h]]")+"-----a"+"a".matches("[a-z&&[^a-h]]"));
		
		/***
		 * 
		 *  d                         数字：[0-9]

			D                         非数字： [^0-9]
			
			s                         空白字符：[ tnx0Bfr]
			
			S                         非空白字符：[^s]
			
			w                         单词字符：[a-zA-Z_0-9]
			
			W                         非单词字符：[^w]
		 */
		p("判断数字和非数字："+"5".matches("d")+"---a:"+"a".matches("d")+"----b:"+"b".matches("D"));
		
		char C=0xB;
		p(C);
		p("判断空格:"+"tnfr".matches("s{4}")+"-------"+"f"".matches("S{2}")+"""".matches("S{2}"));
		p("判断数字+空格："+"a_8".matches("w{2}")+"a".matches("w")+"------_"+"".matches("W"));
		p("abc888&^%".matches("[a-z]{1,3}d+[&^%]+"));
		p("".matches("\"));
		p("判断单词"+"ancffBGG9777".matches("w+")+"----"+"%#$%&^%$##@@@".matches("W+"));
		
		//边界匹配符
		/****
		 * 
		 *    ^                                          行的开头

		      $                                          行的结尾
		
		      b                                        单词边界
		
		      B                                        非单词边界
		
		      A                                        输入的开头
		
		      G                                       上一个匹配的结尾
		
		      Z                                       输入的结尾，仅用于最后的结束符（如果有的话）
		
		      z                                       输入的结尾
		 */
		
		p("hello sir".matches("^h.*")); //以h开头
		p("hello sir".matches(".*ir$")); //以ir结尾
		p("hello sir".matches("^h[a-z]{1,3}obssir"));
		p("hellosir".matches("^h[a-z]{1,3}ob.*")+"----------------"+"hellosir".matches("^h[a-z]{1,3}oB.*"));
		//空白行：一个或多个(空白且非换行符)开头，并以换行符结尾
		p(" n".matches("^[s&&[^n]]*n$"));
		
		//方法解析
		
		/***
		 * 
		 * 
		 *  matches():匹配整个字符串

			find():匹配子字符串
			
			lookingAt():永远从整个字符串的开头开始匹配
		 */
		
		p("测试邮件地址:"+"liuch.....99@q...q....com".matches("[w[.-]]+@[w[.-]]+.[w]+"));
		
		Pattern p1=Pattern.compile("d[3,5]");
		Matcher m1=p1.matcher("123-34345-234-00");
	    //将整个"123-34345-234-00"用正则表达式引擎查找匹配，当到第一个"-"不匹配了，就停止，
        //但不会将不匹配的"-"吐出来
		p(m1.matches());
		 //将不匹配的"-"吐出来
        m1.reset();
        //1:当前面有p(m.matches());查找子字符串从"...34345-234-00"开始
        //将会是第1,2两个查到"34345"和"234" 后面2个查不到为false
        //2:当前面有p(m.matches());和m.reset();查找子字符串从"123-34345-234-00"开始
        //将为true,true,false
        p(m1.find());
        p(m1.start()+"---"+m1.end());
        p(m1.find());
        p(m1.start()+"---"+m1.end());
        p(m1.find());
        p(m1.start()+"---"+m1.end());
        p(m1.find());
        
      //要是没找到就会报异常java.lang.IllegalStateException
        //p(m.start()+"---"+m.end());
        
        p(m1.lookingAt());
        p(m1.lookingAt());
        p(m1.lookingAt());
        p(m1.lookingAt());
        
        //字符串替换
        //Pattern.CASE_INSENSITIVE大小写不敏感
        Pattern  p2=Pattern.compile("java",Pattern.CASE_INSENSITIVE);
        Matcher m2=p2.matcher("java Java jAva ILoveJavA youHateJava adsdsfd");
        //存放字符串
        StringBuffer buffer=new StringBuffer();
        //计数奇偶数
        int i=0;
        while(m2.find()){
        	i++;
        	if(i%2==0){
        		m2.appendReplacement(buffer,"java");
        	}else{
        		m2.appendReplacement(buffer,"JAVA");
        	}
        }
        //不加这句话，，字符串adsdsdf将会被丢弃
        m.appendTail(buffer);
        p(buffer);
        
      //group分组,用()分组
        Pattern p3=Pattern.compile("(d{3,5})([a-z]{2})");
        String s="123aa--34345bb-234cc-000zs";
        Matcher m3=p3.matcher(s);
        p(m3.groupCount());
        while(m3.find()){
        	p("分组："+m3.group());
        	p("分组1："+m3.group(1));
        	p("分组2："+m3.group(2));
        }
	}
	
	
	
	
	
	public static void p(Object o){
		System.out.println(o);
	}

}

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!