JAVA中正则表达式学习总结

时间：2021-11-30 18:51:35

一、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

JAVA中正则表达式学习总结

有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. 字符串边界

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

JAVA中正则表达式学习总结

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());
        }
    }
}

运行结果：

中

国

 

标签：

相关文章