Java中使用正则表达式校验字符串

时间:2022-03-09 14:59:21

Java中使用正则表达式校验字符串

正则表达式是某一位伟大的数学家发明的,现在已经形成了一个ISO标准,这个标准和编程语言没有关系。至于具体谁发明的,怎么发明的,我也忘记了:)。
 
正则表达式简单理解就是用来匹配字符串,看看所给字符串是否与正则表达式匹配,通过匹配关系,可以做很多事情,比如搜索引擎、替换、校验、分割等等。但最基本的还是用来校验匹配关系。 Java SE中早已实现了正则表达式的引擎,并且有着广泛的应用。
 
参考JDK API文档,Java的正则表达式API集中在java.util.regex包里面,其下有两个核心类:
 
软件包 java.util.regex
用于匹配字符序列与正则表达式指定模式的类。
 
接口摘要
MatchResult 匹配操作的结果。
 
类摘要
Matcher 通过解释 Pattern 对 字符序列 执行匹配操作的引擎。
Pattern 正则表达式的编译表示形式。
 
异常摘要
PatternSyntaxException 抛出未经检查的异常,表明正则表达式模式中的语法错误。
 
具体功能很多,用法也很灵活,现在给出一个例子,用来校验一个字符串:
 
这个字符串必须符合如下格式:
1、第一个字母为R,后跟两个数字,然后是一个下划线,后面再跟两个字母,两个数字;还有可以跟一个下划线带两个数字。
2、十一个数字。
3、年度:四个数字,首位必须为1或者2。
4、月份:01~12
以上四个部分之间用横杠连接。
 
例如,一下是格式良好的字符串
R05_QD01-34010000000-2007-12
R23_QD21_02-34010000000-2007-01
 
 
下面给出个例子看看:
import java.util.regex.Pattern; 
import java.util.regex.Matcher; 

/** 
* Created by IntelliJ IDEA. 
* File: RegExDemo.java 
* User: leizhimin 
* Date: 2008-3-10 15:55:24 
*/
 
public  class RegExDemo { 
     private  static String regEx1 =  "R\\d{2}_[A-Z]{2}\\d{2}(_\\d{2})?-\\d{11}-[1|2]\\d{3}-0[1-9]"
     private  static String regEx2 =  "R\\d{2}_[A-Z]{2}\\d{2}(_\\d{2})?-\\d{11}-[1|2]\\d{3}-1[012]"
     private  static String regEx3 =  "R\\d{2}_[A-Z]{2}\\d{2}(_\\d{2})?-\\d{11}-[1|2]\\d{3}-[NABCXQD]"

     /** 
     * 验证报表代码是否符合编码规则 
     * 
     * @param rptCode 报表代码 
     * @return 验证结果,验证通过返回true,失败返回false 
     */
 
     public  static  boolean isRegularRptCode(String rptCode) { 
        Pattern p1 = Pattern.compile(regEx1); 
        Pattern p2 = Pattern.compile(regEx2); 
        Pattern p3 = Pattern.compile(regEx3); 
        Matcher m1 = p1.matcher(rptCode); 
        Matcher m2 = p2.matcher(rptCode); 
        Matcher m3 = p3.matcher(rptCode); 
         boolean rs1 = m1.matches(); 
         boolean rs2 = m2.matches(); 
         boolean rs3 = m3.matches(); 
         return rs1 || rs2 || rs3; 
    } 

     public  static  void main(String args[]) { 
        String s1 =  "R05_QD01-34010000000-2007-12"
         boolean flag1 = isRegularRptCode(s1); 
        System.out.println( "字符串 " + s1 +  " 验证" + (flag1 ?  "成功!" :  "失败!")); 

        String s2 =  "R23_QD21_02-34010000000-2007-01"
         boolean flag2 = isRegularRptCode(s2); 
        System.out.println( "字符串 " + s2 +  " 验证" + (flag2 ?  "成功!" :  "失败!")); 
    } 
}
 
运行结果:
字符串 R05_QD01-34010000000-2007-12 验证成功! 
字符串 R23_QD21_02-34010000000-2007-01 验证成功! 

Process finished with exit code 0 
 
有关正则表达式的用法很简单,其实最关键的是要能写出所需要的正则表达式。有关语法可以参考Java API的java.util.regex.Pattern类。
 
另外,我在附件中给出了网上找到一个正则表达式文档,很不错,一起放上来。
 
下面是另外一个API测试例子:
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 

/** 
* Created by IntelliJ IDEA. 

* @author leizhimin 2007-6-18 16:00:49 
*/
 
public  class TestPattern { 

         public  static  void main(String args[]) { 
                test1(); 
                test2(); 
                test3(); 
        } 

         public  static  void test1() { 
                 //创建正则表达式的模式对象 
                Pattern p = Pattern.compile( "a*b"); //零次或多次a,并跟着b 
                 //通过模式对象创建一个匹配对象 
                Matcher m1 = p.matcher( "aaaaabxyzabt"); 
                Matcher m2 = p.matcher( "aaaaab"); 
                 //尝试将整个区域与模式匹配。当且仅当整个区域序列匹配此匹配器的模式时才返回 true。 
                 boolean b11 = m1.matches(); 
                 boolean b12 = m2.matches(); 
                System.out.println(b11 +  "\t" + b12); 

                 //编译给定正则表达式并尝试将给定输入与其匹配。 
                 boolean b21 = Pattern.matches( "a*b""aaaaabxyzabt"); 
                 boolean b22 = Pattern.matches( "a*b""aaaaab"); 
                System.out.println(b21 +  "\t" + b22); 

                System.out.println(p.flags()); 
        } 

         /** 
         * 进行大小写忽略和多行模式测试 
         */
 
         public  static  void test2() { 
                Pattern p1 = Pattern.compile( "a*b", Pattern.CASE_INSENSITIVE); 
                Pattern p2 = Pattern.compile( "a*b", Pattern.MULTILINE); 

                Matcher m11 = p1.matcher( "aaaaaBABzAbt"); 
                Matcher m12 = p1.matcher( "Ab"); 
                Matcher m21 = p2.matcher( "a\n" +  "b"); 
                Matcher m22 = p2.matcher( "ab"); 

                 boolean b11 = m11.matches(); 
                 boolean b12 = m12.matches(); 
                System.out.println(b11 +  "\t" + b12); 
                 boolean b21 = m21.matches(); 
                 boolean b22 = m22.matches(); 

                System.out.println(b21 +  "\t" + b22); 
                System.out.println(p1.flags());                              //返回此模式的匹配标志。 
                System.out.println(p1.pattern());                          //返回在其中编译过此模式的正则表达式。 
                System.out.println(Pattern.quote( "aaaaa"));      //返回指定 String 的字面值模式 String。 
                String[] arr1 = p1.split( "xabyayAbt");                 //围绕此模式的匹配拆分给定输入序列。 
                 for (String s : arr1) { 
                        System.out.println(s); 
                } 
                String[] arr2 = p1.split( "xabyayAbt", 2);          //围绕此模式的匹配拆分给定输入序列。 
                 for (String s : arr2) { 
                        System.out.println(s); 
                } 
                System.out.println(p1.toString());                         //返回此模式的字符串表示形式。 
        } 

         public  static  void test3() { 
                Pattern p = Pattern.compile( "cat"); 
                Matcher m = p.matcher( "cat two cats in the yard"); 
                System.out.println(m.groupCount()); 
                System.out.println(m.matches()); 
                System.out.println(m.find()); 
                System.out.println(m.find(8)); 
                StringBuffer sb =  new StringBuffer(); 
                 while (m.find()) { 
                        m.appendReplacement(sb,  "dog"); 
                } 
                m.appendTail(sb); 
                System.out.println(sb.toString()); 

                System.out.println(m.replaceAll( "person")); 
                System.out.println(m.replaceFirst( "person")); 

                 while (m.find()) { 
                        System.out.println(m.group()); 
                } 

        } 
}