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

来源：互联网发布：注射死刑知乎编辑：程序博客网时间：2024/05/17 12:54

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

运行结果

[java] view plain copy
 
true  
a****a  
true  
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
 
//初步认识. * + ?  
        p("a".matches("."));//true  
        p("aa".matches("aa"));//true  
        p("aaaa".matches("a*"));//true  
        p("aaaa".matches("a+"));//true  
        p("".matches("a*"));//true  
        p("aaaa".matches("a?"));//false  
        p("".matches("a?"));//true  
        p("a".matches("a?"));//true  
        p("1232435463685899".matches("\\d{3,100}"));//true  
        p("192.168.0.aaa".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));//false  
        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
 
//范围  
        p("a".matches("[abc]"));//true  
        p("a".matches("[^abc]"));//false  
        p("A".matches("[a-zA-Z]"));//true  
        p("A".matches("[a-z]|[A-Z]"));//true  
        p("A".matches("[a-z[A-Z]]"));//true  
        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
 
//认识\s \w \d \  
        p("\n\r\t".matches("\\s(4)"));//false  
        p(" ".matches("\\S"));//false  
        p("a_8 ".matches("\\w(3)"));//false  
        p("abc888&^%".matches("[a-z]{1,3}\\d+[&^#%]+"));//true  
        p("\\".matches("\\\\"));//true  

边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

\B 非单词边界

\A 输入的开头

\G 上一个匹配的结尾

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

\z 输入的结尾

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

方法解析

matches():匹配整个字符串

find():匹配子字符串

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

[java] view plain copy
 
//email  
        p("asdsfdfagf@adsdsfd.com".matches("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+"));//true  
          
        //matches() find() lookingAt()  
        Pattern p = Pattern.compile("\\d{3,5}");  
        Matcher m = p.matcher("123-34345-234-00");  
          
        //将整个"123-34345-234-00"用正则表达式引擎查找匹配，当到第一个"-"不匹配了，就停止，  
        //但不会将不匹配的"-"吐出来  
        p(m.matches());  
        //将不匹配的"-"吐出来  
        m.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,true,false  
        p(m.find());  
        p(m.start()+"---"+m.end());  
        p(m.find());  
        p(m.start()+"---"+m.end());  
        p(m.find());  
        p(m.start()+"---"+m.end());  
        p(m.find());  
        //要是没找到就会报异常java.lang.IllegalStateException  
        //p(m.start()+"---"+m.end());  
          
        p(m.lookingAt());  
        p(m.lookingAt());  
        p(m.lookingAt());  
        p(m.lookingAt());  

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

[java] view plain copy
 
//字符串替换  
        //Pattern.CASE_INSENSITIVE大小写不敏感  
        Pattern p = Pattern.compile("java",Pattern.CASE_INSENSITIVE);  
        Matcher m = p.matcher("java Java jAva ILoveJavA youHateJAVA adsdsfd");  
        //存放字符串  
        StringBuffer  buf = new StringBuffer();  
        //计数奇偶数  
        int i  = 0;  
        while(m.find()){  
            i++;  
            if(i%2 == 0){  
                m.appendReplacement(buf, "java");  
            }else{  
                m.appendReplacement(buf, "JAVA");  
            }  
        }  
        //不加这句话，字符串adsdsfd将会被遗弃  
        m.appendTail(buf);  
        p(buf);  

运行结果：

[java] view plain copy
 
JAVA java JAVA ILovejava youHateJAVA adsdsfd  

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

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

0 0