正则表达式小结

转载请注明出处http://blog.csdn.net/crazy1235/article/details/50532754

基本用法

从JDK1.4开始提供了对正则表达式的支持，位于java.util.regex包里。

主要用到的类就是Pattern和Matcher。

Pattern用于编译你编写的表达式。

public final class Pattern implements java.io.Serializable

Matcher类用于对Pattern编译的表达式进行匹配。

public final class Matcher implements MatchResult

MatchResult接口表示匹配操作的结果。通过MatchResult可以查看匹配边界、组合组边界，但是不能修改。

//返回匹配结果的初始索引
public int start();
//返回捕获子序列的初始索引，group就是分组的编号
public int start(int group);
//返回匹配字符串最后字符的索引
public int end();
//返回捕获子序列的最后字符之后的偏移量
public int end(int group);
//返回匹配捕获的序列串
public String group();
//返回以前匹配期间给定的组序列的串
public String group(int group);
//返回捕获的组数
public int groupCount();

Pattern类常用的方法

public static boolean matches(String regularExpression, CharSequence input) 

这是一个静态方法，用于快速匹配字符串。该方法适合用于一个匹配，并且是匹配全部字符串。

public String[] split(CharSequence input)
public String[] split(CharSequence input, int limit)

用于分割字符串。实际上我们通常用的String.split()方法一部分内部实现就是调用Pattern类的split方法。
两个参数的split方法不常用到。下面简单说一下limit参数的用法：（摘自网络）

limit 参数控制模式应用的次数，因此影响所得数组的长度。如果该限制 n 大于 0，则模式将被最多应用 n - 1 次，数组的长度将不会大于 n，而且数组的最后一项将包含所有超出最后匹配的定界符的输入。如果 n 为非正，那么模式将被应用尽可能多的次数，而且数组可以是任何长度。如果 n 为 0，那么模式将被应用尽可能多的次数，数组可以是任何长度，并且结尾空字符串将被丢弃。 
例如，字符串 "boo:and:foo" 使用这些参数可生成以下结果： 
Regex Limit 结果 
: 2 { "boo", "and:foo" } 
: 5 { "boo", "and", "foo" } 
: -2 { "boo", "and", "foo" } 
o 5 { "b", "", ":and:f", "", "" } 
o -2 { "b", "", ":and:f", "", "" } 
o 0 { "b", "", ":and:f" } 
调用此方法的 str.split(regex, n) 形式与以下表达式产生的结果完全相同： 
Pattern.compile(regex).split(str, n) 

public Matcher matcher(CharSequence input) 

该方法用于返回一个Matcher类的实例。Matcher类的构造是私有的，可以通过Pattern的matcher方法创建。

Matcher类常用的方法

matches():  //匹配整个字符串
find():  //扫描输入串查找与该模式匹配的下一个子序列。有点类似于递归的interator().
lookingAt():  //永远从整个字符串的开头开始匹配

以上三个方法都返回boolean类型。当匹配到时返回true，否则返回false。

start()：  //返回匹配到的子串首字符在总串中的索引
end()：  //返回匹配到的子串最后一个字符在总串中的索引
group()：  //返回匹配到的子串

通过matches()、lookingAt()、find()方法匹配之后，可以利用start()、end()、group()得到具体的信息。

语法介绍

使用之前，得先熟悉正则的语法。下面介绍一下正则的基本语法。熟练掌握这些语法之后，使用正则就很顺了。

匹配

Pattern pattern = Pattern.compile("\\d*");
Matcher matcher = pattern.matcher("123");
System.out.println(matcher.matches());

true

替换

String temp = "a11bs13~!@a#A5cc";
String result = temp.replaceAll("\\d+", "@");
System.out.println(result);

a@bs@~!@a#A@cc

查找

pattern = Pattern.compile("\\w+");
matcher = pattern.matcher("ac!@#Acad_99ac_dd");
System.out.println(matcher.find());

true

分割

temp = "boo:and:foo";
String[] splitStr = temp.split("o");
for (String split : splitStr) {
    System.out.println("--" + split);
}

--b
--
--:and:f

贪婪匹配与懒惰匹配

当正则表达式包含能接受重复的限定符时，通常是尽可能匹配多的字符。比如：以”a\w*b”去匹配”aaabbaab”时，会匹配整个串，得到的结果就是”aaabbaab”，这种就称为贪婪匹配。

但是我们有时候需要去匹配能匹配到但是尽可能少的字符，此时我们可以对正则的限定符添加”?”号。比如：用”a\w*?b”去匹配”aabba2baz!de3baba”的时候，会匹配出”aab”、”a2b”、”ab”。这种就称之为懒惰匹配。

当?字符紧跟其他限定符(*、+、?、{n}、{n,}、{n,m})之后时，匹配模式就是“懒惰的”，尽可能匹配短的字符串，而默认的匹配是“贪心的”。

Pattern pa = Pattern.compile("(a\\w*?b)");
Matcher ma = pa.matcher("aabba2baz~de3baba");
while (ma.find()) {
    System.out.println(ma.group(1));
}

aab
a2b
ab

捕获组与非捕获组

正则语法中使用”()”进行分组。比如，想匹配重复三次的”ab”，就可以这样写：”(ab){3}”。

使用”()”进行分组之后，就可以通过”matcher.group(1)”方法进行获取捕获的组。但是以”(?)”开头的组就是非捕获组，不会捕获文本，不会对组合进行计数。

捕获组

Pattern pattern = Pattern.compile("(\\d+)(m2|%|￥)");
Matcher matcher = pattern.matcher("125%");
while (matcher.find()) {
    System.out.println(matcher.group(1) + " -- " + matcher.group(2));
}

125 -- %

非捕获组

pattern = Pattern.compile("(\\d+)(?:\\.?)(?:\\d+)(m2|%|￥)");
matcher = pattern.matcher("1234.512￥");
while (matcher.find()) {
    System.out.println(matcher.group(1) + " -- " + matcher.group(2));
}

1234 -- ￥

(?= X)

表示当子表达式X在右侧匹配时才继续匹配。

pattern = Pattern.compile("\\w{2}(?=ab)");
matcher = pattern.matcher("23ababc2ab_Aab34");
while (matcher.find()) {
    System.out.println(matcher.group());
}

23
ab
c2
_A

从输出结果可以看出，第二次匹配的时候是从第2个位置开始查找的，而不是从第4个位置开始的。

此表达式等同于(\w{2})(?:ab)。不过要通过group(1)才能获取匹配的串。

(?! X)

表示仅当表达式X不在此位置右侧匹配时才继续匹配。

pattern = Pattern.compile("\\d{2}(?!ab)");
matcher = pattern.matcher("23aa90baab34");
while (matcher.find()) {
    System.out.println(matcher.group());
}

23
90
34

(?<= X)

表示仅当表达式X在此位置左侧匹配时才继续匹配。

pattern = Pattern.compile("(?<=a)\\d*(?=b)");
matcher = pattern.matcher("ssa2ba1a13b");
while (matcher.find()) {
    System.out.println(matcher.group());
}

2
13

(?<! X)

表示仅当表达式X不在此位置左侧匹配时才继续匹配。

pattern = Pattern.compile("(?<!a)\\d*(?=b)");
matcher = pattern.matcher("ssa2ba1a13b");
while (matcher.find()) {
    System.out.println(matcher.group());
}

3

常用正则表达式

18位身份证号

return Pattern.matches("^\\d{6}(?:1|2){1}\\d{3}(0[1-9]|1[0-2])[0-3][0-9](\\d{4}|\\d{3}X)$", idCard);

国内手机号

return Pattern.matches("^(?:\\+?86)?\\s+?(1[34578]\\d{9})$", phoneNumber);

验证密码

（字母开头，只能包括字母、数字、下划线，长度为6-18）

 return Pattern.matches("[A-Za-z]\\w{5,17}", password);

邮箱

Pattern.matches("^\\w+@[0-9a-zA-Z]+\\.[0-9a-zA-Z]+$", email);

参考

http://blog.csdn.net/luosijin123/article/details/4792181
http://www.cnblogs.com/lovingprince/archive/2008/08/06/2166368.html
http://deerchao.net/tutorials/regex/regex.htm

此篇blog到此结束~
感谢大家支持！如有错误，请指出~
谢谢~