黑马程序猿 正则表达公式的学习

正则表达式：符合一定规则的表达式。作用是用于专门操作字符串,可以简化对字符串的复杂操作。

特点：用一些特定的符号来表示一些代码操作，这样就可以简化书写。

好处：可以简化对字符串的复杂操作。

弊端：符号定义越多，正则越长，阅读性越差。

总结：到底用四种功能中的哪个呢？
思路：
1，如果只想知道该字符是对是错，使用匹配。
2，想要将已有的字符串变成另一个字符串，使用替换功能。
3，想要按照自定的方式将字符串变成多个字符串，用切割，获取规则以外的字符。
4，想要拿到符合要求的字符串字串，用获取，获取符合规则的字串。

正则表达式的操作功能：

1.匹配：String Matches()

 

1. public static void checkTel() 
2. { 
3.     String Tel = "13592235644";  
4.     String reg = "1[358]\\d{3-9}"; 
5.     System.out.println(Tel.matches(reg)); 
6. } 

<span style="font-size:18px;">public static void checkTel()
{
	String Tel = "13592235644";	
	String reg = "1[358]\\d{3-9}";
	System.out.println(Tel.matches(reg));
}</span>

2.切割：String split()

 

1. public static void splitDemo(String str,String teg) 
2. { 
3.     String[] arr = str.split(teg); 
4.     for(String s : arr) 
5.     { 
6.         System.out.println(s); 
7.     } 
8. } 
9.  
10. class RegexDomo 
11. { 
12.     public static void main(String[] args)  
13.     { 
14.         splitDemo("zhangsan,lisi,wangwu",","); 
15.         splitDemo("zhangsan   lisi  wangwu"," +"); 
16.         //+表示出现一次或多次。 
17.         splitDemo("c:\\abc\\a.txt","\\\\"); 
18.         //转义字符 
19.         splitDemo("erkktyqqquizzzzzo","(.)\\1+"); 
20.         //按照叠词切割，就是后一个和前一个是一样的。 
21.         /*     
22.         为了让规则的结果可以重用，可以将规则用()封装成组，组都有编号。
23.         从1开始，想要使用已有的组可以通过\n(n就是租的编号)的形式来获取。
24.         ((())()) 有几组就数有几个左括号，第几组也是数左括号，第几个就是第几组。
25.         */ 
26.         String str = "wer13899800000ty123456754uioo"; 
27.         //将字符串中的数字替换成#。 
28.         replaceAllDemo(str,"\\d{5,}","#"); 
29.         String str1 = "erkktyqqquillllojl"; 
30.         //将字符串中的叠词替换成单个字母。zzzz->z 
31.         replaceAllDemo(str1,"(.)\\1+","$1"); 
32.         //$1表示获取第一个组的内容 
33.     } 
34. } 

<span style="font-size:18px;">public static void splitDemo(String str,String teg)
{
	String[] arr = str.split(teg);
	for(String s : arr)
	{
		System.out.println(s);
	}
}

class RegexDomo
{
	public static void main(String[] args) 
	{
		splitDemo("zhangsan,lisi,wangwu",",");
		splitDemo("zhangsan   lisi  wangwu"," +");
		//+表示出现一次或多次。
		splitDemo("c:\\abc\\a.txt","\\\\");
		//转义字符
		splitDemo("erkktyqqquizzzzzo","(.)\\1+");
		//按照叠词切割，就是后一个和前一个是一样的。
		/*		
		为了让规则的结果可以重用，可以将规则用()封装成组，组都有编号。
		从1开始，想要使用已有的组可以通过\n(n就是租的编号)的形式来获取。
		((())()) 有几组就数有几个左括号，第几组也是数左括号，第几个就是第几组。
		*/
		String str = "wer13899800000ty123456754uioo";
		//将字符串中的数字替换成#。
		replaceAllDemo(str,"\\d{5,}","#");
		String str1 = "erkktyqqquillllojl";
		//将字符串中的叠词替换成单个字母。zzzz->z
		replaceAllDemo(str1,"(.)\\1+","$1");
		//$1表示获取第一个组的内容
	}
}
</span>

3. 替换：String replaceAll(String regex,String str)

1. public static void replaceAllDemo(String str,String reg,String newStr) 
2. { 
3.     str = str.replaceAll(reg,newStr); 
4.     System.out.println(str); 
5. } 

<span style="font-size:18px;">public static void replaceAllDemo(String str,String reg,String newStr)
{
	str = str.replaceAll(reg,newStr);
	System.out.println(str);
}
</span>

4.获取：Pattern.compile(Regex) ， Matcher()

 

1. import java.util.regex.*; 
2. //需要用到正则表达式包 
3. class RegexDemo2 
4. { 
5.     public static void getDemo() 
6.     { 
7.         String str = "ming tian jiu yao fang jia le ,da jia"; 
8.         String reg = "\\b[a-z]{3}\\b";  
9.                    // '\b'表示单词边界。 
10.         //取出3个字符组成的单词。 
11.         //将规则封装成对象 
12.  
13.         Pattern p = Pattern.compile(reg); 
14.         //让正则对象和要作用的字符串相关联。 
15.         Matcher m = p.matcher(str); 
16.  
17.         //m.find();//讲规则作用到字符串上，并进行符合规则的字串查找。 
18.         //System.out.println(m.group());//用于获取匹配后的结果。 
19.  
20.         while(m.find) 
21.         { 
22.             System.out.println(m.group()); 
23.              
24.         } 
25.     } 
26. } 

<span style="font-size:18px;">import java.util.regex.*;
//需要用到正则表达式包
class RegexDemo2
{
	public static void getDemo()
	{
		String str = "ming tian jiu yao fang jia le ,da jia";
		String reg = "\\b[a-z]{3}\\b"; 
                   // '\b'表示单词边界。
		//取出3个字符组成的单词。
		//将规则封装成对象

		Pattern p = Pattern.compile(reg);
		//让正则对象和要作用的字符串相关联。
		Matcher m =	p.matcher(str);

		//m.find();//讲规则作用到字符串上，并进行符合规则的字串查找。
		//System.out.println(m.group());//用于获取匹配后的结果。

		while(m.find)
		{
			System.out.println(m.group());
			
		}
	}
}</span>

*********************三个练习*******************

 

1. import java.util.regex.*; 
2. import java.util.*; 
3. class RegexDemo  
4. { 
5.     public static void main(String[] args)  
6.     { 
7.         test_1(); 
8.         regexTest_2(); 
9.         checkMail(); 
10.     } 
11.  
12.  
13.     //需求：将下列字符串变成：我要学编程。 
14.     public static void test_1() 
15.     { 
16.         String str = "我我...我我...我要..要要....学学.....学学..编编编...程...程程..程"; 
17.  
18.         /*
19.         思路：需要将已有字符串变成另一个字符串，使用替换功能。
20.         步骤：1，将所有.去掉。
21.               2，将多个重复的字变成一个字。
22.         */ 
23.  
24.         str = str.replaceAll("\\.+",""); 
25.         //System.out.println(str.replaceAll("(我)\\1+(要)\\2+(学)\\3+(编)\\4+(程)\\5+","$1$2$3$4$5"));  
26.         System.out.println(str); 
27.         String str1 = str.replaceAll("(.)\\1+","$1"); 
28.         System.out.println(str1); 
29.     } 
30.  
31.      
32.     //需求2：将ip地址进行地址段顺序排序。 
33.      
34.     public static void regexTest_2() 
35.     { 
36.         String str = "192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30"; 
37.         str = str.replaceAll("(\\d+)","00$1"); 
38.         System.out.println(str); 
39.         str = str.replaceAll("0*(\\d{3})","$1"); 
40.         System.out.println(str); 
41.         String[] arr = str.split(" +"); 
42.         TreeSet<String> ts = new TreeSet<String>(); 
43.         for(String s : arr) 
44.         { 
45.             ts.add(s); 
46.         } 
47.         for(String s : ts) 
48.         { 
49.             System.out.println(s.replaceAll("0*(\\d+)","$1")); 
50.         } 
51.     } 
52.          
53.      
54.  
55.     //需求3：对邮件地址进行校验 
56.  
57.     public static void checkMail() 
58.     { 
59.         String mail = "1@1.cn.com"; 
60.         boolean b = mail.matches("\\w+@[a-zA-Z0-9]+(\\.[a-zA-Z]+){1,3}"); 
61.         System.out.println(b); 
62.     } 
63.  
64. }