JAVA中正则表达式学习总结

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JAVA中正则表达式学习总结相关的知识,希望对你有一定的参考价值。

一、JAVA中正则表达式相关的类

1. java.util.regex.Pattern

  该类用于编译模式,模式可以理解为一个正则表达式,比如:a*b。

  用法如下:

           // 创建模式

    Pattern p = Pattern.compile("a*b");

    // 创建该模式的匹配器

         Matcher m = p.matcher("aaaaab");

2. java.util.regex.Matcher

  该类用于创建匹配器和进行匹配操作。

  用法如下:

  // 进行匹配操作

  boolean b = m.matches();

3. 运行一个正则表达式入门案例

public class C {
    public static void main(String[] args) {
        new C().test();
    }    
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("a*b");
        // 创建该模式的匹配器
        Matcher m = p.matcher("aaaaab");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

二、正则表达式基础

1.  纯文本也是一个正则表达式

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("ab");
        // 创建该模式的匹配器
        Matcher m = p.matcher("ab");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true;

2. 字符可以匹配任意单个的字符、字母、数字。

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile(".b");
        // 创建该模式的匹配器
        Matcher m = p.matcher("ab");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

3. 用[ ]匹配一组字符

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("[0123456789]");
        // 创建该模式的匹配器,5和[0123456789]中的某一个匹配
        Matcher m = p.matcher("5");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

4. 用-简化[ ]中元素的列举

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("[0-9]");
        // 创建该模式的匹配器
        Matcher m = p.matcher("5");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

类似用法:[a-z]、[A-Z]、[a-zA-Z]、[a-zA-Z0-9]

注意:类似[z-a]的是非法的regex。

-只有在[ ]中才是元字符,如果在[ ]就是一个普通字符。

5. ^取非操作符

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("[^0-9a]");
        // 创建该模式的匹配器,注意^取非是集合[]中所有元素取非,不只是0-9
        Matcher m = p.matcher("a");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:false

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("[^0-9]");
        // 创建该模式的匹配器
        Matcher m = p.matcher("a");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

6. 匹配数字的元字符:\\d 等价于[0-9]

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式,注意在正则表达式中\\也需要转义即:\\\\
        Pattern p = Pattern.compile("\\\\d");
        // 创建该模式的匹配器
        Matcher m = p.matcher("4");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

7. 匹配非数字的元字符:\\D相当于[^0-9]

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\D");
        // 创建该模式的匹配器
        Matcher m = p.matcher("4");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:false

8. \\w:匹配任何一个字母数字字符(大小写均可)或下划线字符(等价于[a-zA-Z0-9_])

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\w");
        // 创建该模式的匹配器
        Matcher m = p.matcher("_");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

9. 匹配任何一个非字母数字或非下划线字符(等价于[^a-zA-Z0-9_])

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\W");
        // 创建该模式的匹配器
        Matcher m = p.matcher("_");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

 

10. +匹配一个或多个(至少一个)。+遇到[ ]一般放在[ ]后,如果放在[ ]中就只是一个元素

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式 +可以重复一个集合[]也可以是一个字符
        Pattern p = Pattern.compile("[abc]+");
        // 创建该模式的匹配器
        Matcher m = p.matcher("aaccbbabc");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\d+");
        // 创建该模式的匹配器
        Matcher m = p.matcher("1114578");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

11. *匹配零个或多个

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\d*");
        // 创建该模式的匹配器
        Matcher m = p.matcher("");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

12. ?匹配零个或一个(最多一个)

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\d?");
        // 创建该模式的匹配器
        Matcher m = p.matcher("");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\d?");
        // 创建该模式的匹配器
        Matcher m = p.matcher("2");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\d?");
        // 创建该模式的匹配器
        Matcher m = p.matcher("25");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:false

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("[abc]?");
        // 创建该模式的匹配器
        Matcher m = p.matcher("c");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

13. { }指定重复匹配的次数

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式  {2}表示匹配两次
        Pattern p = Pattern.compile("[abc]{2}");
        // 创建该模式的匹配器
        Matcher m = p.matcher("cc");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

 

运行结果:true

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式 {2,5}最少匹配2次,最多匹配5次
        Pattern p = Pattern.compile("[abc]{2,5}");
        // 创建该模式的匹配器
        Matcher m = p.matcher("ccab");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

public class C {
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式 最好重复匹配3次
        Pattern p = Pattern.compile("[abc]{3,}");
        // 创建该模式的匹配器
        Matcher m = p.matcher("ccabbbbbbbbbbbbbb");
        // 进行匹配操作
        boolean b = m.matches();
        System.out.println(b);
    }
}

运行结果:true

14. ( )中的|表示“或”

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("t(a|e|i|o|oo)n");
        // 输出匹配结果
        System.out.println(p.matcher("tan").matches());
        System.out.println(p.matcher("ten").matches());
        System.out.println(p.matcher("tin").matches());
        System.out.println(p.matcher("ton").matches());
        //[ ]中只能匹配一个字符,而( )中可以不止一个字符,如“oo”
        System.out.println(p.matcher("toon").matches());
    }
}

运行结果:

true

true

true

true

true

当一个模式使用多次时,以下写法会编译多次,会影响性能.

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        //如果要多次使用一种模式,编译一次后重用此模式比每次都调用此方法效率更高。
        System.out.println(Pattern.matches("t(a|e|i|o|oo)n", "toon"));
    }
}    
运行结果:true

15. \\b指定单词边界,匹配的长度可以认为为“0”。b是英文boundary(边界)的首字母。

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式 
        Pattern p = Pattern.compile("\\\\bis\\\\b");
        // 创建该模式的匹配器
        Matcher m = p.matcher("This is a dog,that is a cat");
        // 进行匹配操作
        while(m.find()){
             System.out.println(m.group());
        }
    }
}    

运行结果:

is

is

技术分享

有4种位置被认为是“单词边界”:

1)在字符串的第一个字符前的位置(如果字符串的第一个字符是一个“单词字符”)

2)在字符串的最后一个字符后的位置(如果字符串的最后一个字符是一个“单词字符”)

3)在一个“单词字符”和“非单词字符”之间,其中“非单词字符”紧跟在“单词字符”之后

4)在一个“非单词字符”和“单词字符”之间,其中“单词字符”紧跟在“非单词字符”后面“单词字符”是可以用“\\w”匹配的字符,“非单词字符”是可以用“\\W”匹配的字符。

 

正则表达式匹配单词的原理探讨:

让我们看看把正则表达式<<\\bis\\b>>应用到字符串“This island is beautiful”。引擎先处理符号<<\\b>>。因为\\b是0长度 ,所以第一个字符T前面的位置会被考察。

因为T是一个“单词字符”,而它前面的字符是一个空字符(void),所以\\b匹配了单词边界。接着<<i>>和第一个字符“T”匹配失败。

匹配过程继续进行,直到第五个空格符,和第四个字符“s”之间又匹配了<<\\b>>。然而空格符和<<i>>不匹配。

继续向后,到了第六个字符“i”,和第五个空格字符之间匹配了<<\\b>>,然后<<is>>和第六、第七个字符都匹配了。

然而第八个字符和第二个“单词边界”不匹配,所以匹配又失败了。到了第13个字符i,因为和前面一个空格符形成“单词边界”,同时<<is>>和“is”匹配。

引擎接着尝试匹配第二个<<\\b>>。因为第15个空格符和“s”形成单词边界,所以匹配成功。引擎“急着”返回成功匹配的结果。

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式 ,匹配以th或Th开头的单词(注意:模式默认是区分大小写的)
        Pattern p = Pattern.compile("(\\\\bth\\\\w+|\\\\bTh\\\\w+)");
        // 创建该模式的匹配器
        Matcher m = p.matcher("This is a dog,that is a cat");
        // 进行匹配操作
        while(m.find()){
             System.out.println(m.group());
        }
    }
}    

运行结果:

This

that

16. 字符串边界

用来定义字符串边界的元字符有两个:一个是用来定义字符串开头的^,另一个是用来定义字符串结尾的$。

技术分享

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式 匹配一个字符串
        Pattern p = Pattern.compile("^this\\\\s+a\\\\s+dog$");
        // 创建该模式的匹配器
        Matcher m = p.matcher("this   a   dog");
        // 进行匹配操作,并输出匹配结果
        while(m.find()){
             System.out.println(m.group());
        }
    }
}    

运行结果:

this   a   dog

17.  注意:重复匹配的元字符(*,?,{3},+)只作用于紧挨着她的的前一个字符或元字符或字表达式。

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("https?");
        // 创建该模式的匹配器
        Matcher m = p.matcher("http");
        //输出匹配的字符串
        while(m.find()){
             System.out.println(m.group());
        }
    }
}

运行结果:

http

18. ()子表达式。子表达式用()包裹起来,可以理解为包含其他元字符的一个元字符。

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}\\\\.\\\\d{1,3}");
        // 创建该模式的匹配器
        Matcher m = p.matcher("Pinging baidu.com [12.159.46.200] with 32 bytes of data");
        //输出匹配的字符串
        while(m.find()){
             System.out.println(m.group());
        }
    }
}    

运行结果:

12.159.46.200

ublic class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式,匹配ip。把上面重复的\\\\d{1,3}\\\\.可以认为是一个字表达式
        Pattern p = Pattern.compile("(\\\\d{1,3}\\\\.){3}\\\\d{1,3}");
        // 创建该模式的匹配器
        Matcher m = p.matcher("Pinging baidu.com [12.159.46.200] with 32 bytes of data;");
        //输出匹配的字符串
        while(m.find()){
             System.out.println(m.group());
        }
    }
}    

运行结果:

12.159.46.200

19. 子表达式的嵌套

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式,匹配19或20开头的年份
        Pattern p = Pattern.compile("(19|20)\\\\d{2}");
        // 创建该模式的匹配器
        Matcher m = p.matcher("today is 2014-4-7");
        //输出匹配的字符串
        while(m.find()){
             System.out.println(m.group());
        }
    }
}    

运行结果:

2014

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式,匹配一个合法IP(最大只能是255)
        Pattern p = Pattern.compile("((\\\\d{1,2}|1\\\\d{2}|2[0-4]\\\\d|25[0-5])\\\\.){3}((\\\\d{1,2}|1\\\\d{2}|2[0-4]\\\\d|25[0-5]))");
        // 创建该模式的匹配器
        Matcher m = p.matcher("IP: 265.255.10.0");
        System.out.println(m.matches());
    }
}    

运行结果:

false

三、常用实例

1. 只匹配中文

public class C { 
    public static void main(String[] args) {
        new C().test();
    }
    public void test(){
        // 创建模式
        Pattern p = Pattern.compile("[\\u4e00-\\u9fa5]");
        // 创建该模式的匹配器
        Matcher m = p.matcher("china中国");
        //输出匹配的字符串
        while(m.find()){
             System.out.println(m.group());
        }
    }
}

运行结果:

 



以上是关于JAVA中正则表达式学习总结的主要内容,如果未能解决你的问题,请参考以下文章

学习java正则与集合框架小总结

20165220 Java第六周学习总结

Java学习总结——(常用类,正则表达式,集合(List,Set) 迭代器)

《JAVA程序设计》第七周学习总结

JavaScript 正则表达式学习

正则表达基础学习