正则表达式基础

<span style="font-size:18px;">package cn.itcast.test;

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

public class Demo1 {
	
	public static void main(String[] args) {
		/*
		//简单认识正则表达式
		System.out.println("abc".matches("..."));
		//.匹配字母
		*/
		/*p("abc".matches("..."));
		
		//d代表0-9的任何一个数组
		//replaceAll把所有的数字替换成-
		//在java中一个反斜杠()代表转义,//""-->输出为  规定d才代表0-9的任何一个数组
		//一定要注意d在java中是d
		p("a45678a".replaceAll("d","-"));
		
		
		//public static Pattern compile(String regex)
		//将给定的正则表达式编译到模式中。
		//把regex这个正则表达式编译下,放到Pattern这个模式中,编译好了,当你再拿这个字符串匹配的时候,速度回快一些
		Pattern pattern = Pattern.compile("[a-z]{3}");
		//[a-z]{3}-->代表三个字母,都是a-z范围
		Matcher matcher = pattern.matcher("dfg");
		//pattern这个模式匹配dfg这个字符串   
		//matcher  匹配方法   
		//Matcher  匹配器
		p(matcher.matches()); //匹配是否成功
		
		//27--33行的代码执行的速度快  36行慢些  没有编译
		p("dfg".matches("[a-z]{3}"));*/
		
		/*
		初步认识 . *  + ?
			. 一个字符
			* 匹配0次或多个字符,a*  就是匹配一个或多个a,匹配串必须都是a
			+ 匹配一个或多个字符
			?匹配0个或一个
			{}-->表示范围
			[]表示某一个字符的范围
		*/
		
		/*p("aaaa".matches("a.")); // false
		p("aaaa".matches("a*")); // true
		p("aaaa".matches("a+")); //true
		p("aaaa".matches("a?")); // false
		 */		
		p("a".matches("."));
		p("aa".matches("aa"));
		p("aaaa".matches("a*"));
		p("aaaa".matches("a+"));
		p("".matches("a*"));
		p("aaaa".matches("a?"));
		p("".matches("a?"));
		p("2321432456789765432".matches("d{3,100}"));//数字的长度在3到100之间
		p("192.168.0.aaa".matches("d{1,3}.d{1,3}"));
		p("192".matches("[0-2][0-9][0-9]"));
		
		/*
		 * 范围
		 * []只匹配一个字符
		 * ^ 代表非或除了什么以外的意思
		 * -  范围
		 * |  或
		 * && 并
		 * */
		p("a".matches("[abc]"));//取出中括号abc其中的一个与a进行匹配
		p("a".matches("[^abc]"));//除了a,b,c以外的字符与a进行匹配
		p("a".matches("[a-zA-Z]"));//所有的大小写字母与a进行匹配
		p("a".matches("[a-z]|[A-Z]"));//a-z或A-Z与a进行匹配
		p("a".matches("[A-Z]&&[RFG]"));
		
		/*
		 * 		认识s w d 		
		 * 
		 *  .  任何字符（与行结束符可能匹配也可能不匹配） 
			d 数字：[0-9] 
			D 非数字： [^0-9] 
			s 空白字符：[ tnx0Bfr] 
			S 非空白字符：[^s] 
			w 单词字符：[a-zA-Z_0-9] 
			W 非单词字符：[^w] 
	   */
		p(" nrt".matches("s{4}"));
		p(" ".matches("S"));
		p("a_8".matches("w{3}"));
		p("abd888&^%".matches("[a-z]{1,3}d+[&^%#]+"));
		p("".matches("\"));//匹配一个反斜杠
		
		//POSIX Style   unix的统一  用的不是太多
		p("a".matches("p{Lower}"));//英文的小写字母
		// 注意p{Upper}或p{Lower}只能判断一个字符，而不是字符串  
		
		//边界匹配(boundary)
		/*
		   ^(开头) 在[]内代表非  在模式串的开头代表第一个字母是什么 
		   $ 末尾
		 */
		p("hello sir".matches("^h.*"));//开头必须是h后面匹配多个0次或多个字符
		p("adasdasd".matches("a.*")); //a后面匹配多个0次或多个字符
		p("adasdasd".matches(".*")); //这是任意的0个或多个字符
		p("adasdasd".matches("a*"));//a后面是0个或多个a  flase
		p("hello sir".matches(".*ir$"));
		p("hello sir".matches("^h[a-z]{1,3}ob.*"));
		p("hellosir".matches("^h[a-z]{1,3}ob.*"));
		
		//空白行
		p(" n".matches("^[s&&[^n]]*n$"));
		//第一个是空格,一个或多个,末尾是n
		
		//练习
		p("aaa 8888c".matches(".*d{4}.")); //true
		p("aaa 8888c".matches(".*bd{4}."));//true
		p("aaa 8888c".matches(".*d{4}."));//true
		p("aaa8888c".matches(".*bd{4}."));//false
		
		//邮箱的匹配
		p("nianxiongdi321@163.com".matches("[a-zA-Z|[0-9]]+@[a-zA-Z|[0-9]]+.[a-zA-Z]{1,6}"));
		p("nianxiongdi321@163.com".matches("[w[.-]]+@[w[.-]]+.[w]+"));
		
		//metches find lookingAt
		
		/*
		 * 		Matcher类的方法:
		 	metches  永远匹配整个字符串
		 	find   找子串
		 	lookingAt 每次从头上找子串
		 	
		 	注意:
		 	  在metches与find一起用的时间,metches在匹配的时候,如果匹配不成功,会把光标停在不匹配的哪里,你在调用find,会接着上一次的光标进行匹配,如果你想从头开始,需要用reset方法重置一下
		 */
		System.out.println("---------------------");
		Pattern pat = Pattern.compile("d{3,5}");
		String s = "123-34354-123-00";
		Matcher m = pat.matcher(s);
		p(m.matches());//模式串与s全部进行匹配
		m.reset();//注意此方法,重置匹配器
		p(m.find());//模式串在s找一个子串进行匹配
		p(m.start()+"-"+m.end());
		p(m.find());
		p(m.start()+"-"+m.end());
		p(m.find());
		p(m.start()+"-"+m.end());
		p(m.find());
		//p(m.start()+"-"+m.end());根据模式串进行匹配的时候,只有找到子串才可以使用start与end方法
		System.out.println("---------------------");
		p(m.lookingAt());
		p(m.lookingAt());
		p(m.lookingAt());

		
		//1.字符串的替换(replacement)
		Pattern p = Pattern.compile("java");//这方法区分大小写
		Matcher ma= p.matcher("java Java JAVA JaVa IloveJAVA you hateJava");
		while(ma.find()){
			p(ma.group());//输出匹配到的子串  分组
		}
		
		//2字符串的替换(replacement)              ?
		Pattern p1 = Pattern.compile("java",Pattern.CASE_INSENSITIVE);//这方法区分大小写  Pattern.CASE_INSENSITIVE   启用不区分大小写的匹配。
		Matcher ma1= p1.matcher("java dsfs  Java JAVA JaVa IloveJAVA you hateJava dsfds");
						//匹配的时候把dsfs  Java看成一个串
		StringBuffer buf = new StringBuffer();
		int i=0;
		while(ma1.find()){
			i++;
			if(i%2==0){
				ma1.appendReplacement(buf,"java");
			}else{
				ma1.appendReplacement(buf,"JAVA");
			}
		}
		ma1.appendTail(buf);
		p(buf);
		
		//1.分组  group
		Pattern p2 = Pattern.compile("d{3,5}[a-z]{2}");
		String  s1 = "132aa-1235bb-132zz-00";
		Matcher m1 = p2.matcher(s1);
		while(m1.find()){//查找子串
			p(m1.group());
		}
		System.out.println("----------------------------------------");
		//2.分组  group
		//d{3,5}[a-z]{2}-->这组正则表达式,用小括号,把他们分开,分成两组,再加上子串本身,共三组,//group默认数组子串的全部  
		// -->(d{3,5})([a-z]{2})-->分组,在多个()时候,只数左小括号,按照1,2,3,4,5...进行编号,在grounp中,直接grounp(n)   n代表你想调用的子串
		Pattern p5 = Pattern.compile("(d{3,5})([a-z]{2})");
		String  s5 = "132aa-1235bb-132zz-00";
		Matcher m5 = p5.matcher(s5);
		while(m5.find()){//查找子串
			p(m5.group(2));
		}
		
		
		
		
		
	}
	
	public static void p(Object o){
		System.out.println(o);
	}
}
</span>

（编辑：李大同）

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