Java 正则表达式 以及Pattern ,Matcher ,PatternSyntaxException类详解

原文链接 Java 正则表达式 以及Pattern ,Matcher ,PatternSyntaxException类详解

概念

正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。

符号说明

  1. 英文句点.
    匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式。

  2. 中括号 []
    字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a"。

  3. 符号^
    匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与"\n"或"\r"之后的位置匹配。与[]组合成反向字符集。匹配未包含的任何字符。例如,"[^abc]"配"plain"中"p","l","i","n"。

  4. 表示匹配次数的符号
    * 零次或多次匹配前面的字符或子表达式。

    + 一次或多次匹配前面的字符或子表达式。

    ? 零次或一次匹配前面的字符或子表达式。

    {n}n 是非负整数。正好匹配 n 次。

    {n,}n 是非负整数。至少匹配 n 次。

    {n,m}m 和 n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。

  5. 符号 |
    表示或,x|y匹配 x 或 y。

  6. 符号 \\
    将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如, n匹配字符 n。\n 匹配换行符。序列 \\ 匹配 \ ,\( 匹配 (。

  7. 符号 -
    与[]配合使用,表示字符范围。匹配指定范围内的任何字符。

  8. 符号()
    匹配 pattern 并捕获该匹配的子表达式。即正则表达式支持如算数表达式中()的运算

特殊符号说明

  1. \d表示[0—9]
  2. \D表示[^0—9]
  3. \w表示[0—9A—Z_a—z]
  4. \W表示[^0—9A—Z_a—z]
  5. \s表示[\t\n\r\f]
  6. \S表示[^\t\n\r\f]

java.util.regex 包下主要三个类

Pattern类

 
  
//常用函数
//Compiles the given regular expression into a pattern.编译为pattern对象
public static Pattern compile(String regex) {
return new Pattern(regex, 0);
}
// 创建Matcher对象,用于匹配字符串
public Matcher matcher(CharSequence input) {
if (!compiled) {
synchronized(this) {
if (!compiled)
compile();
}
}
Matcher m = new Matcher(this, input);
return m;
}
//匹配字符串
public static boolean matches(String regex, CharSequence input) {
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(input);
return m.matches();
}
// 字符串拆分,String中的split函数底层就是
// return Pattern.compile(regex).split(this, limit);
public String[] split(CharSequence input, int limit) ;
.....省略

小结

Pattern类对于正则表达式,先进行编译,并且Pattern 类没有公共构造方法。要创建一个 Pattern 对象,你必须首先调用其公共静态编译方法,它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。最后再通过matcher 进行字符串的匹配。

Matcher 类:

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。

 
  
//创建此匹配器的Pattern 对象。
Pattern parentPattern;
//设置Pattern对象,以及需要匹配的字符串
Matcher(Pattern parent, CharSequence text) {
this.parentPattern = parent;
this.text = text;
// Allocate state storage
int parentGroupCount = Math.max(parent.capturingGroupCount, 10);
groups = new int[parentGroupCount * 2];
locals = new int[parent.localCount];
// Put fields into initial states
reset();
}
//重设Pattern对象
public Matcher usePattern(Pattern newPattern);
//重设Matcher 状态,设置新的字符串
public Matcher reset();
public Matcher reset(CharSequence input) {
text = input;
return reset();
}
//Matcher.matches()、Matcher.lookingAt()、Matcher.find()
//Matcher.matches()是堆整个字符串进行匹配
public boolean matches() {
return match(from, ENDANCHOR);
}
//Matcher.lookingAt()从开头开始匹配。即从第一个字母就开始匹配,但不需要匹配整个字符串
public boolean lookingAt() {
return match(from, NOANCHOR);
}
//Matcher.find()尝试寻找与模式匹配的输入序列的下一个子序列,就是能匹配到子序列就行了
public boolean find() {
int nextSearchIndex = last;
if (nextSearchIndex == first)
nextSearchIndex++;
// If next search starts before region, start it at region
if (nextSearchIndex < from)
nextSearchIndex = from;
// If next search starts beyond region then it fails
if (nextSearchIndex > to) {
for (int i = 0; i < groups.length; i++)
groups[i] = -1;
return false;
}
return search(nextSearchIndex);
}
// Mathcer.start()、Matcher.end()、Matcher.group()
//当执行了当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息:
//start()返回匹配到的子字符串的第一个字符在原字符串中的索引位置;
//end()返回匹配到的子字符串的最后一个字符在原字符串中的索引位置;
//group()返回匹配到的子字符串。
//只有当匹配操作成功,才可以使用start(),end(),group()三个方法
//对group分析
//调用group()其实是group(0)
public String group() {
return group(0);
}
//
public String group(int group);
String content = "I am noob " +
"from runoob.com.";
String pattern = "(oo).*(com)";
Pattern com= Pattern.compile(pattern);
Matcher matcher =com.matcher(content);
while(matcher.find())
{
System.out.println("matcher.group(0) "+matcher.group(0));//得到第0组——整个匹配
System.out.println("matcher.group(0) "+matcher.group(1));//得到第1组——整个匹配
System.out.println("matcher.group(0) "+matcher.group(2));//得到第2组——整个匹配
/**
*matcher.group(0) oob from runoob.com
*matcher.group(0) oo
*matcher.group(0) com
*即group(0)是返回整个正则表达式匹配的结过
*index参数表示每个()内的子正则表达式的结果
*/
//可以通过while(m.find())来获取所有匹配的字符串
while (m.find()) {
System.out.println(m.group());
System.out.print("start:" + m.start());
System.out.println(" end:" + m.end());
}
//Mathcer.replaceAll(String replacement) 和 Mathcer.replaceFirst(String replacement),String replace的底层也是这个函数
//将最后一次匹配工作后剩余的字符串添加到一个StringBuffer对象里。
public StringBuffer appendTail(StringBuffer sb) {
sb.append(getSubSequence(lastAppendPosition, getTextLength()).toString());
return sb;
}
// 将区域设置为从 start 参数指定的索引处开始,并在 end 参数指定的索引处结束。
public Matcher region(int start, int end);

小结

匹配字符串的具体操作都在matcher上

PatternSyntaxException类

表达式错误异常

总结

Pattern与Matcher共同进行字符串匹配,Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. 单独用Pattern只能使用Pattern.matches(String regex,CharSequence input)一种最基础最简单的匹配。
操作代码:

 
  
Pattern pattern = Pattern.compile("regex");
Matcher m = pattern.matcher("str");
//再根据需求,调用Matcher的函数即可

你可能感兴趣的:(java,正则表达式,开发语言)