黑马程序员——Java正则表达式

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

Java正则表达式

一：什么是正则表达式

1. 定义：正则表达式是一种可以用于模式匹配和替换的规范，一个正则表达式就是有普通的字符以及特殊字符组成的文字模式，它用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

2. 用途：

• 字符串匹配
• 字符串查找
• 字符串替换
• 字符串分割

    例如：

• 从网页中揪出email地址
• IP地址是否正确
• 从网页中揪出链接

3. java中处理正则表达式的类

java.lang.String

java.util.regex.Pattern: 模式类：字符串要被匹配的这么一个模式，该模式本身已经被编译过，使用的话效率要高很多。

java.util.regex.Matcher: 匹配类： 这个模式匹配某个字符串所产生的结果，这个结果可能会有很多个。

4. 常用表达式

// 反斜杠
/t 间隔 ('/u0009')
/n 换行 ('/u000A')
/r 回车 ('/u000D')
/d 数字 等价于[0-9]
/D 非数字 等价于[^0-9]
/s 空白符号 [/t/n/x0B/f/r]
/S 非空白符号 [^/t/n/x0B/f/r]
/w 单独字符 [a-zA-Z_0-9]
/W 非单独字符 [^a-zA-Z_0-9]
/f 换页符
/e Escape
/b 一个单词的边界
/B 一个非单词的边界
/G 前一个匹配的结束

^为限制开头
^java     条件限制为以Java为开头字符
$为限制结尾
java$     条件限制为以java为结尾字符
.  条件限制除/n以外任意一个单独字符
java..     条件限制为java后除换行外任意两个字符


加入特定限制条件「[]」
[a-z]     条件限制在小写a to z范围中一个字符
[A-Z]     条件限制在大写A to Z范围中一个字符
[a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符
[0-9]     条件限制在小写0 to 9范围中一个字符
[0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符
[0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集)

[]中加入^后加再次限制条件「[^]」
[^a-z]     条件限制在非小写a to z范围中一个字符
[^A-Z]     条件限制在非大写A to Z范围中一个字符
[^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符
[^0-9]     条件限制在非小写0 to 9范围中一个字符
[^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符
[^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集)

在限制条件为特定字符出现0次以上时，可以使用「*」
J*     0个以上J
.*     0个以上任意字符
J.*D     J与D之间0个以上任意字符

在限制条件为特定字符出现1次以上时，可以使用「+」
J+     1个以上J
.+     1个以上任意字符
J.+D     J与D之间1个以上任意字符

在限制条件为特定字符出现有0或1次以上时，可以使用「?」
JA?     J或者JA出现

限制为连续出现指定次数字符「{a}」
J{2}     JJ
J{3}     JJJ
文字a个以上，并且「{a,}」
J{3,}     JJJ,JJJJ,JJJJJ,???(3次以上J并存)
文字个以上，b个以下「{a,b}」
J{3,5}     JJJ或JJJJ或JJJJJ
两者取一「|」
J|A     J或A
Java|Hello     Java或Hello
 
「()」中规定一个组合类型
比如，我查询<a href=/"index.html/">index</a>中<a href></a>间的数据，可写作<a.*href=/".*/">(.+?)</a>

在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数：
Pattern Pattern.compile(String regex, int flag)

flag的取值范围如下：
Pattern.CANON_EQ     当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式"a/u030A"会匹配"?"。默认情况下，不考虑"规 范相等性(canonical equivalence)"。
Pattern.CASE_INSENSITIVE(?i)     默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹 配，只要将UNICODE_CASE与这个标志合起来就行了。
Pattern.COMMENTS(?x)     在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注：不是指表达式里的"//s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。
Pattern.DOTALL(?s)     在这种模式下，表达式'.'可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式'.'不匹配行的结束符。
Pattern.MULTILINE
(?m)     在这种模式下，'^'和'$'分别匹配一行的开始和结束。此外，'^'仍然匹配字符串的开始，'$'也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。
Pattern.UNICODE_CASE
(?u)     在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。
Pattern.UNIX_LINES(?d)     在这个模式下，只有'/n'才被认作一行的中止，并且与'.'，'^'，以及'$'进行匹配。

5. 程序示例：

[java]  view plain  copy  

1. import java.util.regex.Matcher;  
2. import java.util.regex.Pattern;  
3.   
4. public class Test {  
5.   
6.     public static void main(String[] args) {  
7.         //matches()判断字符串是否匹配某个表达式，"."表示任何一个字符  
8.         p("abc".matches("..."));  
9.         //将字符串"a2389a"中的数字用*替换，\d 表示“0--9”数字  
10.         p("a2389a".replaceAll("\\d", "*"));  
11.         //将任何是a--z的字符串长度为3的字符串进行编译，这样可以加快匹配速度  
12.         Pattern p = Pattern.compile("[a-z]{3}");  
13.         //进行匹配，并将匹配结果放在Matcher对象中  
14.         Matcher m = p.matcher("abc");  
15.         p(m.matches());  
16.         //上面的三行代码可以用下面一行代码代替  
17.         p("abc".matches("[a-z]{3}"));  
18.     }  
19.       
20.     public static void p(Object o){  
21.         System.out.println(o);  
22.     }  
23. }  

运行结果

[java]  view plain  copy  

1. true  
2. a****a  
3. true  
4. true  

现在通过一些实验来说明正则表达式的匹配规则,这儿是Greedy方式

  .              任何字符

 a?             a一次或一次也没有

 a*             a零次或多次

 a+            a一次或多次

 a{n}?      a恰好 n 次

 a{n,}?       a至少n次 

 a{n,m}?   a至少n次，但是不超过m次

[java]  view plain  copy  

1. //初步认识. * + ?  
2.         p("a".matches("."));//true  
3.         p("aa".matches("aa"));//true  
4.         p("aaaa".matches("a*"));//true  
5.         p("aaaa".matches("a+"));//true  
6.         p("".matches("a*"));//true  
7.         p("aaaa".matches("a?"));//false  
8.         p("".matches("a?"));//true  
9.         p("a".matches("a?"));//true  
10.         p("1232435463685899".matches("\\d{3,100}"));//true  
11.         p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));//false  
12.         p("192".matches("[0-2][0-9][0-9]"));//true  

[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]（减去）

[java]  view plain  copy  

1. //范围  
2.         p("a".matches("[abc]"));//true  
3.         p("a".matches("[^abc]"));//false  
4.         p("A".matches("[a-zA-Z]"));//true  
5.         p("A".matches("[a-z]|[A-Z]"));//true  
6.         p("A".matches("[a-z[A-Z]]"));//true  
7.         p("R".matches("[A-Z&&[RFG]]"));//true  

\d                          数字：[0-9]

\D                         非数字： [^0-9]

\s                          空白字符：[ \t\n\x0B\f\r]

\S                         非空白字符：[^\s]

\w                         单词字符：[a-zA-Z_0-9]

\W                        非单词字符：[^\w]

[java]  view plain  copy  

1. //认识\s \w \d \  
2.         p("\n\r\t".matches("\\s(4)"));//false  
3.         p(" ".matches("\\S"));//false  
4.         p("a_8 ".matches("\\w(3)"));//false  
5.         p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));//true  
6.         p("\\".matches("\\\\"));//true  

 边界匹配器

      ^                                          行的开头

      $                                          行的结尾

      \b                                        单词边界

      \B                                        非单词边界

      \A                                        输入的开头

      \G                                       上一个匹配的结尾

      \Z                                       输入的结尾，仅用于最后的结束符（如果有的话）

      \z                                       输入的结尾

[java]  view plain  copy  

1. //边界匹配  
2.         p("hello sir".matches("^h.*"));//true  
3.         p("hello sir".matches(".*ir$"));//true  
4.         p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));//true  
5.         p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));//false  
6.         //空白行:一个或多个(空白并且非换行符)开头，并以换行符结尾  
7.         p(" \n".matches("^[\\s&&[^\\n]]*\\n$"));//true  

 方法解析

matches():匹配整个字符串

find():匹配子字符串

lookingAt():永远从整个字符串的开头开始匹配

[java]  view plain  copy  

1. //email  
2.         p("[e-mail]".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+"));//true  
3.           
4.         //matches() find() lookingAt()  
5.         Pattern p = Pattern.compile("\\d{3,5}");  
6.         Matcher m = p.matcher("123-34345-234-00");  
7.           
8.         //将整个"123-34345-234-00"用正则表达式引擎查找匹配，当到第一个"-"不匹配了，就停止，  
9.         //但不会将不匹配的"-"吐出来  
10.         p(m.matches());  
11.         //将不匹配的"-"吐出来  
12.         m.reset();  
13.           
14.         //1:当前面有p(m.matches());查找子字符串从"...34345-234-00"开始  
15.         //将会是第1,2两个查到"34345"和"234" 后面2个查不到为false  
16.         //2:当前面有p(m.matches());和m.reset();查找子字符串从"123-34345-234-00"开始  
17.         //将为true,true,true,false  
18.         p(m.find());  
19.         p(m.start()+"---"+m.end());  
20.         p(m.find());  
21.         p(m.start()+"---"+m.end());  
22.         p(m.find());  
23.         p(m.start()+"---"+m.end());  
24.         p(m.find());  
25.         //要是没找到就会报异常java.lang.IllegalStateException  
26.         //p(m.start()+"---"+m.end());  
27.           
28.         p(m.lookingAt());  
29.         p(m.lookingAt());  
30.         p(m.lookingAt());  
31.         p(m.lookingAt());  

字符串替换：下面这种方法对于字符串替换非常灵活

[java]  view plain  copy  

1. //字符串替换  
2.         //Pattern.CASE_INSENSITIVE大小写不敏感  
3.         Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);  
4.         Matcher m = p.matcher("java Java jAva ILoveJavA youHateJAVA adsdsfd");  
5.         //存放字符串  
6.         StringBuffer  buf = new StringBuffer();  
7.         //计数奇偶数  
8.         int i  = 0;  
9.         while(m.find()){  
10.             i++;  
11.             if(i%2 == 0){  
12.                 m.appendReplacement(buf, "java");  
13.             }else{  
14.                 m.appendReplacement(buf, "JAVA");  
15.             }  
16.         }  
17.         //不加这句话，字符串adsdsfd将会被遗弃  
18.         m.appendTail(buf);  
19.         p(buf);  

运行结果：

[java]  view plain  copy  

1. JAVA java JAVA ILovejava youHateJAVA adsdsfd  

[java]  view plain  copy  

1. //group分组,用()分组  
2.         Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");  
3.         String s = "123aa-34345bb-234cc-00";  
4.         Matcher m = p.matcher(s);  
5.         p(m.groupCount());//2组  
6.         while(m.find()){  
7.             p(m.group());//数字字母都有  
8.             //p(m.group(1));//只有数字  
9.             //p(m.group(2));//只有字母  
10.         }  

------ Java培训、Android培训、iOS培训、.Net培训 、期待与您交流！ -------