主要用到的类就是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方法不常用到。
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 = "bo:and:fo";
String[] splitStr = temp.split("o");
for (String split : splitStr) {
System.out.print(split+"-");
}
结果:b- :and:f-
常用正则表达式
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);
捕获组与非捕获组
正则语法中使用”()”进行分组。比如,想匹配重复三次的”ab”,就可以这样写:”(ab){3}”。
使用”()”进行分组之后,就可以通过”matcher.group(1)”方法进行获取捕获的组。但是以”(?)”开头的组就是非捕获组,不会捕获文本,不会对组合进行计数。
捕获组
Pattern pattern = Pattern.compile("(\\d+)(m²|%|¥)");
Matcher matcher = pattern.matcher("125%");
while (matcher.find()) {
System.out.println(matcher.group(1) + " -- " + matcher.group(2));
}
输出结果:125 – %
非捕获组
pattern = Pattern.compile("(\\d+)(?:\\.?)(?:\\d+)(m²|%|¥)");
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
贪婪匹配与懒惰匹配
当正则表达式包含能接受重复的限定符时,通常是尽可能匹配多的字符。比如:以”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
参考博客:http://blog.csdn.net/crazy1235/article/details/50532754