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

时间:2023-02-19 09:47:09

------<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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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]                        ab 或 c(简单类)

[^abc]                      任何字符,除了 ab 或 c(否定)

[a-zA-Z]                   a 到 z 或 A 到 Z,两头的字母包括在内(范围)

[a-d[m-p]]                a 到 d 或 m 到 p[a-dm-p](并集)

[a-z&&[def]]             de 或 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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  1. //email  
  2.         p("asdsfdfagf@adsdsfd.com".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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  1. JAVA java JAVA ILovejava youHateJAVA adsdsfd  

[java]  view plain  copy   黑马程序员——Java正则表达式 黑马程序员——Java正则表达式
  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培训 、期待与您交流! -------