码迷，mamicode.com
首页 > 编程语言 > 详细

JAVA中正则表达式学习总结

时间：2017-10-27 23:02:26      阅读：251      评论：0      收藏：0      [点我收藏+]

标签：pre   元素   模式   数字   单词   public   开头   分享   嵌套   

一、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中正则表达式学习总结

标签：pre   元素   模式   数字   单词   public   开头   分享   嵌套   

原文地址：http://www.cnblogs.com/zheting/p/7745506.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！