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 ? "成功!" : "失败!"));
}
}
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
字符串 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());
}
}
}
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());
}
}
}
本文转自 leizhimin 51CTO博客，原文链接：http://blog.51cto.com/lavasoft/64994，如需转载请自行联系原作者
