正则运算

捕获组

 

捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。

 

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class regexDemo03 {
//捕获组
    public static void main(String[] args) {
        // 按指定模式在字符串查找
        String line = "This order was placed for QT3000! OK?";
        String pattern = "(\\D*)(\\d+)(.*)";
         // 创建 Pattern 对象
        Pattern p =Pattern.compile(pattern);
        // 现在创建 matcher 对象
        Matcher m =p.matcher(line);
        System.out.println(m.groupCount());
        
        if (m.find( )) {
             System.out.println("Found value: " + m.group(0) );
             System.out.println("Found value: " + m.group(1) );
             System.out.println("Found value: " + m.group(2) );
             System.out.println("Found value: " + m.group(3) ); 
          } else {
             System.out.println("NO MATCH");
          }
    }
}

 

编译结果：

3
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?

 

正则表达式语法

在 Java 中正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。

 

常用的字符

\d    数字字符匹配。等效于 [0-9]。

\D    非数字字符匹配。等效于 [^0-9]。

\n    换行符匹配。等效于 \x0a 和 \cJ。

\w   匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。

\W  与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。
+    一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。

 

 

 

 

索引方法

索引方法提供了有用的索引值，精确表明输入字符串中在哪能找到匹配：

序号	方法及说明
1	public int start()  返回以前匹配的初始索引。
2	public int start(int group)  返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引
3	public int end() 返回最后匹配字符之后的偏移量。
4	public int end(int group) 返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。

 

 

start 和 end 方法

下面是一个对单词 "cat" 出现在输入字符串中出现次数进行计数的例子：

RegexMatches.java 文件代码：

package regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class regexDemo04 {
     private static final String REGEX = "\\bcat\\b";
        private static final String INPUT =
                                        "cat cat cat cattie cat";
     
        public static void main( String args[] ){
           Pattern p = Pattern.compile(REGEX);
           Matcher m = p.matcher(INPUT); // 获取 matcher 对象
           int count = 0;
     
           while(m.find()) {
             count++;
             System.out.println("Match number "+count);
             System.out.println("start(): "+m.start());
             System.out.println("end(): "+m.end());
          }
       }
}

以上实例编译运行结果如下：

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

可以看到这个例子是使用单词边界，以确保字母 "c" "a" "t" 并非仅是一个较长的词的子串。它也提供了一些关于输入字符串中匹配发生位置的有用信息。

Start 方法返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引，end 方法最后一个匹配字符的索引加 1。

 

matches 和 lookingAt 方法

matches 和 lookingAt 方法都用来尝试匹配一个输入序列模式。它们的不同是 matches 要求整个序列都匹配，而lookingAt 不要求。

lookingAt 方法虽然不需要整句都匹配，但是需要从第一个字符开始匹配。

 

package regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class regexDemo05 {
    
     
    
        private static final String REGEX = "foo";
        private static final String INPUT = "fooooooooooooooooo";
        private static final String INPUT2 = "ooooofoooooooooooo";
        private static Pattern pattern;
        private static Matcher matcher;
        private static Matcher matcher2;
     
        public static void main( String args[] ){
           pattern = Pattern.compile(REGEX);
           matcher = pattern.matcher(INPUT);
           matcher2 = pattern.matcher(INPUT2);
     
           System.out.println("Current REGEX is: "+REGEX);
           System.out.println("Current INPUT is: "+INPUT);
           System.out.println("Current INPUT2 is: "+INPUT2);
     
     
           System.out.println("lookingAt(): "+matcher.lookingAt());
           System.out.println("matches(): "+matcher.matches());
           System.out.println("lookingAt(): "+matcher2.lookingAt());
       }
    }

 

replaceFirst 和 replaceAll 方法

replaceFirst 和 replaceAll 方法用来替换匹配正则表达式的文本。不同的是，replaceFirst 替换首次匹配，replaceAll 替换所有匹配。

 

package regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class regexDemo06 {

     
    
        private static String REGEX = "dog";
        private static String INPUT = "The dog says meow. " +
                                        "All dogs say meow.";
        private static String REPLACE = "cat";
     
        public static void main(String[] args) {
           Pattern p = Pattern.compile(REGEX);
           // get a matcher object
           Matcher m = p.matcher(INPUT); 
           INPUT = m.replaceAll(REPLACE);
           System.out.println(INPUT);
       }
    }