正则表达式中的基本正则规则详解01

正则表达式 前端之家
前端之家收集整理的这篇文章主要介绍了正则表达式中的基本正则规则详解01，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

转载原文章链接:http://www.jb51.cc/article/p-mumenqay-bqm.html

字符组

  • 正则表达式的最基本结构之一。
  • 作用:规定某个位置能够出现的字符。
  • 形式:以”[…]”给出，在方括号内列出字符。或者简写字符。
  • 方括号中的字符为某个位置是否出现的字符，例如[123]，如果当前位置出现1或者2或者3的话，它都能匹配，但是只能出现一个数字。

例子:
判断十进制字符。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li1 {
    public static void main(String[] args) {
         String string="4";
         String rex="[0123456789]";

         Pattern pattern=Pattern.compile(rex);
         Matcher matcher=pattern.matcher(string);

         System.out.println("/*********本例子用于判断数字是不是十进制*********/");

         if(matcher.matches()){
             System.out.println("\t\t是十进制数");
         }else{
             System.out.println("\t\t不是十进制数");
         }
    }
}

运行结果:

/*********本例子用于判断数字是不是十进制*********/
        是十进制数

连字符

这个是连字符 “-”
但是上面的例子用来表示十进制[0123456789]太过累赘，所以可以使用连字符用来简化，但是连字符只能够简化是相连接，中间没有空缺的。即可以这样表示[0-9]就行了。也可以这样表示[0-789]这样也是可以的，想要表达的意思就是用了连字符只是起到简化的作用。

可以测试下:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li1 {
    public static void main(String[] args) {
         String string="4";
         String rex="[0-9]";

         Pattern pattern=Pattern.compile(rex);
         Matcher matcher=pattern.matcher(string);

         System.out.println("/*********本例子用于判断数字是不是十进制*********/");

         if(matcher.matches()){
             System.out.println("\t\t是十进制数");
         }else{
             System.out.println("\t\t不是十进制数");
         }
    }
}

运行结果:

/*********本例子用于判断数字是不是十进制*********/
        是十进制数

注意事项

  • 在字符组的内部，只有当连字符出现在两个字符之间时，才能表示字符的范围；如果出现在字符组的开头或者结尾，则只能够表示单个字符’-‘即连字符本身这个字符。

排除型字符组

  • 作用:规定某个位置不容许出现的字符。
  • 形式:以”[^…]”给出，在方括号内列出不容许出现的字符。
  • 排除型字符组仍然必须匹配一个字符。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li2 {
         public static void main(String[] args) {
            String [] strs={"1","2","a","A","\n","\t","\r"," ","哈"};
            String rex="[^123]";

            Pattern pattern=Pattern.compile(rex);

            for(String str:strs){
                Matcher matcher=pattern.matcher(str);
                System.out.println("字符串:"+str+"匹配结果"+"["+matcher.matches()+"]");
            }
        }
}

运行结果:

字符串:[1]匹配结果[false]
字符串:[2]匹配结果[false]
字符串:[a]匹配结果[true]
字符串:[A]匹配结果[true]
字符串:[
]匹配结果[true]
字符串:[   ]匹配结果[true]
字符串:[
]匹配结果[true]
字符串:[ ]匹配结果[true]
字符串:[哈]匹配结果[true]

所以排除型表示的意思就是排除当前的字符，然后满足其他的所有字符。

字符组简记法

  • 对于常用的字符组，正则表达式提供了相应的简记法，方便地表示它们。
  • \d 相当于 [0-9]
  • \D 相当于 [^0-9]
  • \w 相当于 [0-9a-zA-Z_]
  • \W相当于 [^0-9a-zA-Z_]
  • \s 匹配空白字符（回车\r、换行\n、制表、空格）
  • \S 匹配非空白字符
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li3 {
          public static void main(String[] args) {
            String rex1="\\d";
            String rex2="\\D";
            String rex3="\\w";
            String rex4="\\W";
            String rex5="\\s";
            String rex6="\\S";

            String [] string=new String[]{"1","B","b","呵","!","！"};

            System.out.println("/*************\\d****************/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex1);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"["+str+"]"+"匹配["+rex1+"]");
                }else{
                    System.out.println("字符串:"+"["+str+"]"+"不匹配["+rex1+"]");
                }
            }

            System.out.println("/*************\\D****************/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex2);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"["+str+"]"+"匹配["+rex2+"]");
                }else{
                    System.out.println("字符串:"+"["+str+"]"+"不匹配["+rex2+"]");
                }
            }

            System.out.println("/*************\\w****************/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex3);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"["+str+"]"+"匹配["+rex3+"]");
                }else{
                    System.out.println("字符串:"+"["+str+"]"+"不匹配["+rex3+"]");
                }
            }

                System.out.println("/*************\\W****************/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex4);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"["+str+"]"+"匹配["+rex4+"]");
                }else{
                    System.out.println("字符串:"+"["+str+"]"+"不匹配["+rex4+"]");
                }
            }

                    System.out.println("/*************\\s****************/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex5);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"["+str+"]"+"匹配["+rex5+"]");
                        }else{
                            System.out.println("字符串:"+"["+str+"]"+"不匹配["+rex5+"]");
                        }
                    }

                    System.out.println("/*************\\S****************/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex6);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"["+str+"]"+"匹配["+rex6+"]");
                        }else{
                            System.out.println("字符串:"+"["+str+"]"+"不匹配["+rex6+"]");
                        }
                    }


        }
}

运行结果:

/*************\d****************/
字符串:[1]匹配[\d]
字符串:[2]匹配[\d]
字符串:[A]不匹配[\d]
字符串:[B]不匹配[\d]
字符串:[a]不匹配[\d]
字符串:[b]不匹配[\d]
字符串:[
]不匹配[\d]
字符串:[   ]不匹配[\d]
字符串:[
]不匹配[\d]
字符串:[ ]不匹配[\d]
字符串:[呵]不匹配[\d]
字符串:[!]不匹配[\d]
字符串:[！]不匹配[\d]
/*************\D****************/
字符串:[1]不匹配[\D]
字符串:[2]不匹配[\D]
字符串:[A]匹配[\D]
字符串:[B]匹配[\D]
字符串:[a]匹配[\D]
字符串:[b]匹配[\D]
字符串:[
]匹配[\D]
字符串:[   ]匹配[\D]
字符串:[
]匹配[\D]
字符串:[ ]匹配[\D]
字符串:[呵]匹配[\D]
字符串:[!]匹配[\D]
字符串:[！]匹配[\D]
/*************\w****************/
字符串:[1]匹配[\w]
字符串:[2]匹配[\w]
字符串:[A]匹配[\w]
字符串:[B]匹配[\w]
字符串:[a]匹配[\w]
字符串:[b]匹配[\w]
字符串:[
]不匹配[\w]
字符串:[   ]不匹配[\w]
字符串:[
]不匹配[\w]
字符串:[ ]不匹配[\w]
字符串:[呵]不匹配[\w]
字符串:[!]不匹配[\w]
字符串:[！]不匹配[\w]
/*************\W****************/
字符串:[1]不匹配[\W]
字符串:[2]不匹配[\W]
字符串:[A]不匹配[\W]
字符串:[B]不匹配[\W]
字符串:[a]不匹配[\W]
字符串:[b]不匹配[\W]
字符串:[
]匹配[\W]
字符串:[   ]匹配[\W]
字符串:[
]匹配[\W]
字符串:[ ]匹配[\W]
字符串:[呵]匹配[\W]
字符串:[!]匹配[\W]
字符串:[！]匹配[\W]
/*************\s****************/
字符串:[1]不匹配[\s]
字符串:[2]不匹配[\s]
字符串:[A]不匹配[\s]
字符串:[B]不匹配[\s]
字符串:[a]不匹配[\s]
字符串:[b]不匹配[\s]
字符串:[
]匹配[\s]
字符串:[   ]匹配[\s]
字符串:[
]匹配[\s]
字符串:[ ]匹配[\s]
字符串:[呵]不匹配[\s]
字符串:[!]不匹配[\s]
字符串:[！]不匹配[\s]
/*************\S****************/
字符串:[1]匹配[\S]
字符串:[2]匹配[\S]
字符串:[A]匹配[\S]
字符串:[B]匹配[\S]
字符串:[a]匹配[\S]
字符串:[b]匹配[\S]
字符串:[
]不匹配[\S]
字符串:[   ]不匹配[\S]
字符串:[
]不匹配[\S]
字符串:[ ]不匹配[\S]
字符串:[呵]匹配[\S]
字符串:[!]匹配[\S]
字符串:[！]匹配[\S]

特殊的简记法:点号

  • 点号 “.”是一个特殊的字符组简记法，它可以匹配几乎所有的字符。
  • “\.”匹配点号本身。
  • 在字符组内部，[.]也只能够匹配点号本身。
  • 注意:点号不能够匹配换行符及回车符但能匹配制表符。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li4 {
         public static void main(String[] args) {
            String rex1=".";
            String rex2="\\.";
            String rex3="[.]";

            String [] string=new String[]{"1","！",".","。"};

            System.out.println("/*************.****************/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex1);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex1+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex1+"\"");
                }
            }

            System.out.println("/*************\\.****************/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex2);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex2+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex2+"\"");
                }
            }

            System.out.println("/*************[.]****************/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex3);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex3+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex3+"\"");
                }
            }
        }
}

运行结果:

/*************.****************/
字符串:"1"匹配"."
字符串:"2"匹配"."
字符串:"A"匹配"."
字符串:"B"匹配"."
字符串:"a"匹配"."
字符串:"b"匹配"."
字符串:"
"不匹配"."
字符串:" "匹配"."
字符串:"
"不匹配"."
字符串:" "匹配"."
字符串:"呵"匹配"."
字符串:"!"匹配"."
字符串:"！"匹配"."
字符串:"."匹配"."
字符串:"。"匹配"."
/*************\.****************/
字符串:"1"不匹配"\."
字符串:"2"不匹配"\."
字符串:"A"不匹配"\."
字符串:"B"不匹配"\."
字符串:"a"不匹配"\."
字符串:"b"不匹配"\."
字符串:"
"不匹配"\."
字符串:" "不匹配"\."
字符串:"
"不匹配"\."
字符串:" "不匹配"\."
字符串:"呵"不匹配"\."
字符串:"!"不匹配"\."
字符串:"！"不匹配"\."
字符串:"."匹配"\."
字符串:"。"不匹配"\."
/*************[.]****************/
字符串:"1"不匹配"[.]"
字符串:"2"不匹配"[.]"
字符串:"A"不匹配"[.]"
字符串:"B"不匹配"[.]"
字符串:"a"不匹配"[.]"
字符串:"b"不匹配"[.]"
字符串:"
"不匹配"[.]"
字符串:" "不匹配"[.]"
字符串:"
"不匹配"[.]"
字符串:" "不匹配"[.]"
字符串:"呵"不匹配"[.]"
字符串:"!"不匹配"[.]"
字符串:"！"不匹配"[.]"
字符串:"."匹配"[.]"
字符串:"。"不匹配"[.]"

量词

  • 作用:限定之前的字符出现的次数
  • 形式:
  • “*” :之前的字符可以出现0次到无穷多次
  • “+” :之前的字符可以出现1次到无穷多次
  • “?” :之前的字符至多只能出现1次，即0次或者1次
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li5 {
         public static void main(String[] args) {
            String rex1="a*";
            String rex2="a?";
            String rex3="a+";

            String [] string=new String[]{"","aa","aaa"};

            System.out.println("/--------------a*-----------------/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex1);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex1+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex1+"\"");
                }
            }

             System.out.println("/--------------a?-----------------/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex2);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex2+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex2+"\"");
                }
            }

                System.out.println("/--------------a+-----------------/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex3);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex3+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex3+"\"");
                }
            }
        }
}

运行结果:

/--------------a*-----------------/
字符串:""匹配"a*"
字符串:"a"匹配"a*"
字符串:"aa"匹配"a*"
字符串:"aaa"匹配"a*"
/--------------a?-----------------/
字符串:""匹配"a?"
字符串:"a"匹配"a?"
字符串:"aa"不匹配"a?"
字符串:"aaa"不匹配"a?"
/--------------a+-----------------/
字符串:""不匹配"a+"
字符串:"a"匹配"a+"
字符串:"aa"匹配"a+"
字符串:"aaa"匹配"a+"

区间量词

  • 作用:具体规定字符的出现次数
  • 形式:
  • {min,max}即最小出现min次最多出现max次
  • {min,}即最小出现min次最多为无穷次
  • {number}即规定必须出现number次
  • “*” 相当于 {0,}
  • “+” 相当于{1,}
  • “?” 相当于 {0,1}
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li6 {
           public static void main(String[] args) {
               String rex1="a{2,4}";
            String rex2="a{2,}";
            String rex3="a{3}";

            String [] string=new String[]{"","aaa","aaaa","aaaaa","aaaaaa"};

               System.out.println("/--------------a{2,4}-----------------/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex1);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex1+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex1+"\"");
                }
            }

           System.out.println("/--------------a{2,}-----------------/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex2);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex2+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex2+"\"");
                }
            }

             System.out.println("/--------------a{3}-----------------/");

            for(String str:string){
                Pattern pattern=Pattern.compile(rex3);
                Matcher matcher=pattern.matcher(str);
                if(matcher.matches()){
                    System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex3+"\"");
                }else{
                    System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex3+"\"");
                }
            }
        }
}

运行结果:

/--------------a{2,4}-----------------/
字符串:""不匹配"a{2,4}"
字符串:"a"不匹配"a{2,4}"
字符串:"aa"匹配"a{2,4}"
字符串:"aaa"匹配"a{2,4}"
字符串:"aaaa"匹配"a{2,4}"
字符串:"aaaaa"不匹配"a{2,4}"
字符串:"aaaaaa"不匹配"a{2,4}"
/--------------a{2,}-----------------/
字符串:""不匹配"a{2,}"
字符串:"a"不匹配"a{2,}"
字符串:"aa"匹配"a{2,}"
字符串:"aaa"匹配"a{2,}"
字符串:"aaaa"匹配"a{2,}"
字符串:"aaaaa"匹配"a{2,}"
字符串:"aaaaaa"匹配"a{2,}"
/--------------a{3}-----------------/
字符串:""不匹配"a{3}"
字符串:"a"不匹配"a{3}"
字符串:"aa"不匹配"a{3}"
字符串:"aaa"匹配"a{3}"
字符串:"aaaa"不匹配"a{3}"
字符串:"aaaaa"不匹配"a{3}"
字符串:"aaaaaa"不匹配"a{3}"

量词的局限,括号的使用

  • 量词只能规定之前字符或字符组的出现次数（只能匹配单个字符）
  • 如果要规定一个字符串的出现次数，必须使用括号”()”，在括号内填写字符串，在闭括号之后添加量词。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li7 {
           public static void main(String[] args) {
               String rex1="ac+";
               String rex2="(ac)+";
               String rex3="ac*";
               String rex4="(ac)*";
               String rex5="ac?";
               String rex6="(ac)?";

               String [] string=new String[]{"","ac","acc","accc","acacac","acac","c"};

                 System.out.println("/--------------ac+-----------------/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex1);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex1+"\"");
                        }else{
                            System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex1+"\"");
                        }
                    }

                   System.out.println("/--------------(ac)+-----------------/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex2);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex2+"\"");
                        }else{
                            System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex2+"\"");
                        }
                    }

                     System.out.println("/--------------ac*-----------------/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex3);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex3+"\"");
                        }else{
                            System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex3+"\"");
                        }
                    }


                     System.out.println("/--------------(ac)*-----------------/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex4);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex4+"\"");
                        }else{
                            System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex4+"\"");
                        }
                    }

                     System.out.println("/--------------ac?-----------------/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex5);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex5+"\"");
                        }else{
                            System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex5+"\"");
                        }
                    }

                 System.out.println("/--------------(ac)?-----------------/");

                    for(String str:string){
                        Pattern pattern=Pattern.compile(rex6);
                        Matcher matcher=pattern.matcher(str);
                        if(matcher.matches()){
                            System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex6+"\"");
                        }else{
                            System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex6+"\"");
                        }
                    }
        }
}

运行结果:

/--------------ac+-----------------/
字符串:""不匹配"ac+"
字符串:"ac"匹配"ac+"
字符串:"acc"匹配"ac+"
字符串:"accc"匹配"ac+"
字符串:"acacac"不匹配"ac+"
字符串:"acac"不匹配"ac+"
字符串:"a"不匹配"ac+"
字符串:"c"不匹配"ac+"
/--------------(ac)+-----------------/
字符串:""不匹配"(ac)+"
字符串:"ac"匹配"(ac)+"
字符串:"acc"不匹配"(ac)+"
字符串:"accc"不匹配"(ac)+"
字符串:"acacac"匹配"(ac)+"
字符串:"acac"匹配"(ac)+"
字符串:"a"不匹配"(ac)+"
字符串:"c"不匹配"(ac)+"
/--------------ac*-----------------/
字符串:""不匹配"ac*"
字符串:"ac"匹配"ac*"
字符串:"acc"匹配"ac*"
字符串:"accc"匹配"ac*"
字符串:"acacac"不匹配"ac*"
字符串:"acac"不匹配"ac*"
字符串:"a"匹配"ac*"
字符串:"c"不匹配"ac*"
/--------------(ac)*-----------------/
字符串:""匹配"(ac)*"
字符串:"ac"匹配"(ac)*"
字符串:"acc"不匹配"(ac)*"
字符串:"accc"不匹配"(ac)*"
字符串:"acacac"匹配"(ac)*"
字符串:"acac"匹配"(ac)*"
字符串:"a"不匹配"(ac)*"
字符串:"c"不匹配"(ac)*"
/--------------ac?-----------------/
字符串:""不匹配"ac?"
字符串:"ac"匹配"ac?"
字符串:"acc"不匹配"ac?"
字符串:"accc"不匹配"ac?"
字符串:"acacac"不匹配"ac?"
字符串:"acac"不匹配"ac?"
字符串:"a"匹配"ac?"
字符串:"c"不匹配"ac?"
/--------------(ac)?-----------------/
字符串:""匹配"(ac)?"
字符串:"ac"匹配"(ac)?"
字符串:"acc"不匹配"(ac)?"
字符串:"accc"不匹配"(ac)?"
字符串:"acacac"不匹配"(ac)?"
字符串:"acac"不匹配"(ac)?"
字符串:"a"不匹配"(ac)?"
字符串:"c"不匹配"(ac)?"

括号的用途:多选结构

  • 字符组只能表示某个位置可能出现的单个字符，而不能表示某个位置可能出现的字符串。
  • 作用:表示某个位置可能出现的字符串，或者可能出现的多个字符串。
  • 形式:
  • “(…|…)”,在竖线两端添加各个字符串
  • “(…|…|…|…)”
public class li8 {
      public static void main(String[] args) {
          String [] string=new String[]{"this","that","thit"};

          String rex="th[ia][st]";

          Pattern pattern=Pattern.compile(rex);

          for(String str:string){
              Matcher matcher=pattern.matcher(str);
              if(matcher.matches()){
                  System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex+"\"");
              }else{
                  System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex+"\"");
              }
          }
    }
}

运行结果:

字符串:"this"匹配"th[ia][st]"
字符串:"that"匹配"th[ia][st]"
字符串:"thit"匹配"th[ia][st]"

而我们不想匹配错误的单词thit怎么办呢？？
看例子:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li8 {
      public static void main(String[] args) {
          String [] string=new String[]{"this","thit"};

          String rex="this|that";//也可以写成th(is|at) 这样把公共提出来后可以提高正则匹配效率。

          Pattern pattern=Pattern.compile(rex);

          for(String str:string){
              Matcher matcher=pattern.matcher(str);
              if(matcher.matches()){
                  System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex+"\"");
              }else{
                  System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex+"\"");
              }
          }
    }
}

运行结果:

字符串:"this"匹配"this|that"
字符串:"that"匹配"this|that"
字符串:"thit"不匹配"this|that"

括号的用途:捕获分组

  • 作用:将括号内的子表达式捕获的字符串存放到匹配的结果中，供匹配完成后访问。
  • 形式: 使用普通的括号”(…)”。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li9 {
      public static void main(String[] args) {
         String email="webmaster@itcast.net";

         String rex="(\\w+)@([\\w.]+)";

         Pattern pattern=Pattern.compile(rex);

         Matcher matcher=pattern.matcher(email);

         if(matcher.find()){
             System.out.println("email add is:\t"+matcher.group(0));//默认打印的是整个匹配的结果
             System.out.println("username is:\t"+matcher.group(1));//打印从左到右第一个括号内的结果
             System.out.println("hostname is:\t"+matcher.group(2));//打印从左到右第二个括号内的结果
         }
    }
}

运行结果:

email add is:   webmaster@itcast.net
username is:    webmaster
hostname is:    itcast.net

需要强调的是:括号的先后顺序按照左括号的出现顺序编号，编号从1开始。编号0为整个正则表达式的匹配结果！！

捕获分组的注意事项

  • 只要使用了括号，就存在捕获分组。
  • 捕获分组按照开括号出现的从左到右的顺序编号，编号从1开始，遇到括号嵌套的情况也是如此。
  • 如果捕获分组之后存在量词，则匹配结果中，捕获分组保存的是子表达式最后一次的匹配字符串。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li10 {

    public static void main(String[] args) {

        explainGroupNo();

        System.out.println("");

        explainGroupQuantifier();       

    }

    public static void explainGroupNo() {

        String email = "webmaster@itcast.net";

        String regex = "((\\w+)@([\\w.]+))";

        Pattern p = Pattern.compile(regex);

        Matcher m = p.matcher(email);

        if (m.find()) {
            System.out.println("match result:\t" + m.group(0));
            System.out.println("group No.1 is:\t" + m.group(1));
            System.out.println("group No.2 is:\t" + m.group(2));
            System.out.println("group No.3 is:\t" + m.group(3));
        }
    }

    public static void explainGroupQuantifier() {
        String email = "webmaster@itcast.net";

        String regex = "(\\w)+@([\\w.])+";

        Pattern p = Pattern.compile(regex);

        Matcher m = p.matcher(email);

        if (m.find()) {
            System.out.println("match result:\t" + m.group(0));
            System.out.println("group No.1 is:\t" + m.group(1));
            System.out.println("group No.2 is:\t" + m.group(2));
        }
    }

}

运行结果:

match result:   webmaster@itcast.net
group No.1 is:  webmaster@itcast.net
group No.2 is:  webmaster
group No.3 is:  itcast.net

match result:   webmaster@itcast.net
group No.1 is:  r
group No.2 is:  t

不捕获文本的括号

  • 如果正则表达式很复杂，或者需要处理的文本很长，捕获分组会降低效率。
  • 作用:仅仅用来对表达式分组，而不把分组捕获的文本存入结果。
  • 形式：”(?:…)”。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li11 {
           public static void main(String[] args) {
                String email = "webmaster@itcast.net";

                String rex="(?:webmaster|admin)@([\\w.]+)";

                Pattern pattern=Pattern.compile(rex);

                Matcher matcher=pattern.matcher(email);

                if(matcher.find()){
                    System.out.println("match result:\t"+matcher.group(0));
                    System.out.println("group No.1 is:\t" + matcher.group(1));
                    //System.out.println(matcher.group(2));
                }
        }
    }

运行结果:

match result:   webmaster@itcast.net
group No.1 is:  itcast.net

因为只要出现了括号就会存在捕获分组，并且会保存捕获结果，但是使用(?:…)就不会保存捕获结果了。所以当要输出编号为1的时候就输出了第二个括号的内容。而不会输出第一个括号的捕获内容，因为第一个括号的捕获内容不会保存！！编号0依然是整个正则表达式匹配的内容。

括号的用途:反向引用

  • 作用:在表达式的某一部分，动态重复之前的子表达式所匹配的文本。
  • 形式:”\1” 其中的1为捕获分组的编号。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li12 {
        public static void main(String[] args) {
              String [] string=new String[]{"<h1>呵呵</h1>","<h1>123</h2>"};

              String rex="<(\\w+)>[^<]+<(/\\1)>";

              Pattern pattern=Pattern.compile(rex);

              for(String str:string){
                  Matcher matcher=pattern.matcher(str);
                  if(matcher.matches()){
                      System.out.println("字符串:"+"\""+str+"\""+"匹配\""+rex+"\"");
                  }else{
                      System.out.println("字符串:"+"\""+str+"\""+"不匹配\""+rex+"\"");
                  }
              }
        }
}

运行结果:

字符串:"<h1>呵呵</h1>"匹配"<(\w+)>[^<]+<(/\1)>" 字符串:"<h1>123</h2>"不匹配"<(\w+)>[^<]+<(/\1)>"

例子：去掉重复单词

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li13 {
            public static void main(String[] args) {        

                One();
                System.out.println();
                Two();          

            }

            private static void Two() {
                String string="hello hello";

                String rex="((\\w+)\\s+\\2)";

                Pattern pattern=Pattern.compile(rex);
                Matcher matcher=pattern.matcher(string);

                System.out.println("字符串:"+string);

                System.out.println("去掉后:"+matcher.replaceAll("$2"));//美元符号可视为到如上所述已捕获子序列的引用

            }

            private static void One() {
                String string="java java";
                String rex="(\\w+)\\s+\\1";
                System.out.println("字符串:"+string);
                System.out.println("去掉后:"+string.replaceAll(rex,"$1"));//美元符号可视为到如上所述已捕获子序列的引用 
            }
}

运行结果:

字符串:java java
去掉后:java

字符串:hello hello
去掉后:hello

到了这个阶段，我想读者也有一定能力了。来看看这个文章:

强调在正则中只要单纯用了括号就会有捕获分组保存

锚点

  • 作用：规定匹配的位置。
  • 形式： “\b”单词分界符锚点。
  • 单词分界符的意思是划分单词和符号之间的界限。注意:这些符号还包括换行、空格、制表符、回车符。当然读者不要想多了，符号就只有空格那几个，符号还包括中文的符号和英文的符号如”!”,”！”，英文感叹号，中文感叹号！！！等，你所
    知道的一切符号！！！

例子:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li15 {
       public static void main(String[] args) {
           String [] strings=new String[] 
                   {"我爱 java ","我爱 html5 ","我爱 \"java\"","我爱 javase"
                   };

           String rex="\\bjava\\b";

           Pattern pattern=Pattern.compile(rex);

           for(String str:strings){
               Matcher matcher=pattern.matcher(str);
               if(matcher.find()){
                   System.out.println("字符串:["+str+"]有");
               }else{
                   System.out.println("字符串:["+str+"]没有");
               }
               System.out.println();
           }
    }
}

运行结果:

字符串:[我爱 java ]有

字符串:[我爱 html5 ]没有

字符串:[我爱 "java"]有

字符串:[我爱 javase]没有

注意事项：

  • \b表示单词分界符，要求一侧是单词字符，另一侧是非单词字符。
  • 单词字符通常是指英文字符、数字字符和中文。
  • 非单词字符通常指的是各种标点符号和空白字符。
  • 如果上面这三条注意事项不是很明白，可以看这篇博客详解正则表达式中的\B和\b

锚点二

  • “^” 匹配一行的开头(有可能变化)，但是在没有设置匹配模式的情况下（即默认情况下），它是匹配整个字符串的开头和\A一样。
  • “$” 匹配一行的末尾(有可能变化)但是在没有设置匹配模式的情况下（即默认情况下），它是匹配整个字符串的结尾和\Z一样。
  • “\A” 匹配整个字符串的开头
  • “\Z” 匹配整个字符串的末尾
  • 如果想要 “^”和 “$”在一整段字符串中匹配逻辑行的开头或者结尾的话，需要修改匹配模式。
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class li16 {
          public static void main(String[] args) {
              String[] strings = new String[] { "start "," start "," end "," end" };

              String[] regexes = new String[] { "^start","\\Astart","end$","end\\Z"};

              for (String str : strings) {
                  for (String regex : regexes) {
                      Pattern p = Pattern.compile(regex);
                      Matcher m = p.matcher(str);
                      if(m.find()) {
                          System.out.println("\"" + str
                                  + "\" can be matched with regex \"" + regex
                                  + "\"");
                      }
                      else {
                          System.out.println("\"" + str
                                  + "\" can not be matched with regex \"" + regex
                                  + "\"");
                      }
                  }
                  System.out.println("");
              }
        }
}

运行结果:

"start " can be matched with regex "^start"
"start " can be matched with regex "\Astart"
"start " can not be matched with regex "end$"
"start " can not be matched with regex "end\Z"

" start " can not be matched with regex "^start"
" start " can not be matched with regex "\Astart"
" start " can not be matched with regex "end$"
" start " can not be matched with regex "end\Z"

" end " can not be matched with regex "^start"
" end " can not be matched with regex "\Astart"
" end " can not be matched with regex "end$"
" end " can not be matched with regex "end\Z"

" end" can not be matched with regex "^start"
" end" can not be matched with regex "\Astart"
" end" can be matched with regex "end$"
" end" can be matched with regex "end\Z"

猜你在找的正则表达式相关文章

常用正则表达式-手机号、身份证、邮箱
一、校验数字的表达式 1 数字：^[0-9]*$ 2 n位的数字：^d{n}$ 3 至少n位的数字：^d{n,}$ 4...
JS正则表达式详解
正则表达式非常有用，查找、匹配、处理字符串、替换和转换字符串，输入输出等。下面整理一...
组内正则培训记录
0. 注： 不同语言中的正则表达式实现都会有一些不同。下文中的代码示例除特别说明的外，都...
高级正则表达式技术（Python版）
 正则表达式是从信息中搜索特定的模式的一把瑞士军刀。它们是一个巨大的工具库，其中的...
史上最全最常用的正则表达式
一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,...
正则表达式工具
正则表达式初步
分享5个可视化的正则表达式编辑工具
　　正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编...
分享5个可视化的正则表达式编辑工具
正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编辑器...
[知识积累]--正则表达式记忆表
在工作中常常遇到正则表达式问题，有时候又会忘记这则的语法。 下面就分享一份正则表达式记...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript