Java中的正则表达式

最新推荐文章于 2025-08-12 21:03:53 发布

原创最新推荐文章于 2025-08-12 21:03:53 发布 · 437 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #正则表达式 #正则 #Pattern #Matcher

thinking in java 专栏收录该内容

1 篇文章

订阅专栏

概念：
一种强大的而且灵活的文本处理工具。使用正则表达式，可以以编程的方式构造复杂的文本模式，并对输入的字符串进行搜索。

字符

Java中正则的字符：

    B              指定字符B
    \xhh        十六进制值为oxhh的字符
    \t             制表符
    \n            换行符
    \r             回车
    \f             换页
    \e            转义
    \\            正则中的反斜线，这和其他语言不一样，其他语言是\，\\\\表示一个普通的斜杠

字符类：

    .                    任意字符
    [abc]             包含a、b和c的任何字符（和a|b|c作用相同）
    [^abc]           除了a、b、c之外的任何字符（^表否定）
    [a-zA-Z]                     从a到z或从A到Z的任何字符（范围）
    [abc[hij]]                    任意a、b、c、h、i、j字符（与a|b|c|h|i|j作用相同）
    [a-z&&[hij]]               任意h、i、或j（搞不清这和[hij]有什么不同）
    \\s                 空白符（空格、tab、换行、换页、和回车）
    \\S                非空白符（[^\s]）
    \\d                数字[0-9]
    \\D               非数字[^0-9]
    \\w               词字符[a-zA-Z0-9]
    \\W              非字符集[^\w]

边界统配符：

    ^                 一行的起始
    $                 一行的结束
    \\b              词的的边界
    \\B              非词的边界
    \\G             前一个匹配的结束

量词：

    ？               出现0次或1次    
    +                至少出现1次  
    *                 出现0次货多次
    {n}              恰好出现n次
    {n,}             至少出现n次
    {n.m}          至少出现n次，至多出现m次

String类中的正则表达式：

String类中带有一些方法可以进行正则表达式的使用与搜索，
如使用matches(reg)根据进行完全匹配，返回boolean
使用split(reg)根据reg进行打断，返回一个数组
使用replaceFirst(reg,String)将匹配上reg的首个字符或字符串替换成String
使用relaceAll(reg,String)将所有匹配上reg的字符或字符串替换成String

一个简单的案例：

//使用String类的matches()方法，进行匹配
public class TestReg{
    public static void main(String[] args) {
        String str =  "abctab345bct";
        System.out.println("-2".matches("-?\\d+"));        //出现0次或1次-，其后跟随的数字至少出现1次，返回true
        System.out.println("28989".matches("(-|\\+)?\\d+)"));     //-或+出现0次或1次，+为特殊字符，需要用\\反斜杠转义，其后跟随的数字至少出现1次，返回true
        System.out.println(str.replaceFirst("a[b|c]", "that"));  //将str中首个ab或ac替换成that
        System.out.println(str.replaceAll("a[b|c]", “that"));   //将str中所有ab或ac替换成that
    }
}

关于Pattern类：

Pattern对象表示编译后的正则表达式。
在上面的TestTeg类中，我们可以使用Pattern来进行匹配，
如：System.out.println(Pattern.matches("(-|\\+)?\\d+)", "28989"); //这和上面的效果一样，实际上在Stirng中的matches中调用的正是这个方法；
使用Pattern进行分割字符串,complie(reg)方法先将正则表示编译，在String类中的split()方法中也可以看到这个身影：
Pattern.complie("!!").split("This!!unusual use!!of exclamation!!points"); //以!!为分隔符，进行分割
Pattern.complie("!!").split("This!!unusual use!!of exclamation!!points", 3); //和上面不同的是,这里多了个参数3，表示总的分成3段，就算后面还有!!也不进行分割了

关于Matcher类：

Matcher是Pattern进行编译、匹配之后返回的类型，它里面保存了一些匹配的信息。
我们可以通过find()方法，在Matcher中查找是否有匹配的信息。
例如在这个例子中：

public class TestMatcher{
    public static viod mian(String[] args) {

        String[] input = new String[]{"abcabcabcabcdefabc", "abc+", "(abc)+", "(abc){2,}"};
        System.out.println("input: ---> " + input[0]);

        for (String str : input) {
            System.out.println("test: ---> " + str);
            Pattern p = Pattern.compile(str);            //将str作为正则 编译
            Matcher m = p.matcher(input[0]);         //对input[0]进行匹配

            while (m.find) {          //m.find() 在Matcher中查找有没有匹配成功的，如果有返回true

                //m.group()表示从Matcher中查找出的匹配的信息，start()返回匹配的起始位置，end()-1返回匹配的末点位置
                System.out.println("Matcher: >>> \"" +m.group() + "\" at " + m.start() + "-" + (m.end()-1) );
            }
        }
    }
}

当然，除了find()方法，我们还有其他的进行查询的方法：

public class TestMatcher2() {
    public static void main(String[] args) {
        Pattern p = Pattern.complie("abc");       //abc最为正则进行编译
        Matcher m = p.matcher("inabcc");          //匹配字符串inabcc

        System.out.println("find >>> " + m.find());           //遍历整个字符串，进行匹配查询，返回boolean
        System.out.println("find-3 >>> " + m.find(3));      //从字符串下标为3的位置开始遍历匹配，返回boolean
        System.out.println("matches >>> " + m.matches());      //字符串作为一个整体，不进行遍历，完全匹配才返回true
        System.out.println("lookAt >>> " + m.lookingAt());      //判断字符串的起始部分是否可以匹配正则
    }
}

在Matcher中有一个重要的方法group(),上面我们已经用到了这个方法，group()中也可以带参数。
在正则表达式中，我们可以用()产生分组，而在Matcher中通过group来区分这些分组，
group()不带参数，默认表示第0组，即整个匹配上正则表达式，
group(1)表示匹配正则表达式中第一个()中的内容，依此类推。
例如：

public class TestMatcherGroup {
    public static void main(String[] args) {
        String ip = "10.70.39.20@02/10/2005\n" +
            "10.63.85.110@04/02/2006\n" +
            "10.60.78.118@12/04/2014";
        System.out.println(ip);
        //这里只进行简单的匹配，使用了2个()
        Pattern p = Pattern.compile("(\\d+[.]\\d+[.]\\d+[.]\\d+)@" + 
                        "(\\d{2}/\\d{2}/\\d{4})");
        Matcher m = p.matcher(ip);

        while (matcher.find()) {
            System.out.println("groupCount >>>>> " + m.groupCount());      //总的数量
            System.out.println("group-0 >>>>>>> " + m.group());    //这个正则
            System.out.println("group-1 >>>>>>> " + m.group(1));   //第一个()
            System.out.println("group-2 >>>>>>> " + m.group(2));   //第二个()
        }
    }
}