java中的正则表达式

正则表达式实例

一个字符串其实就是一个简单的正则表达式，例如 Hello World 正则表达式匹配 "Hello World" 字符串。

.（点号）也是一个正则表达式，它匹配任何一个字符如："a" 或 "1"。

下表列出了一些正则表达式的实例及描述：

              

               

java.util.regex 包主要包括以下三个类：

• Pattern 类：

  pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

• Matcher 类：

  Matcher 对象是对输入字符串进行解释和匹配操作的引擎。（对正则表达式匹配输入字符串）与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

• PatternSyntaxException：

  PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

  以下实例中使用了正则表达式 .*runoob.* 用于查找字符串中是否包了 runoob 子串：

 

package regex;

import java.util.regex.Pattern;

public class RegexExample {

	public static void main(String[] args) {
		String content = " I am bob" + "from runoob .com . ";
		String pattern = ".*runoob.*";
		boolean isMatch = Pattern.matches(pattern, content);
        System.out.println("字符串中是否包含了runoob子串?" + isMatch);	    
	}

}

 

String content =" abstract";

.*为贪婪匹配,表示匹配尽量多的任意字符。

如：  a.*t  ----->  abstract

.*？为懒惰（非贪婪）匹配，表示匹配尽量少的任意字符。

 如：  a.*？t  ----->  abst

捕获组

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

例如，正则表达式 (dog) 创建了单一分组，组里包含"d"，"o"，和"g"。

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

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

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

还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

下面的例子说明如何从一个给定的字符串中找到数字串：

package regex;

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

public class RegexMatches {

	public static void main(String[] args) {
		// 按指定模式在字符串中查找
		String line = "This order was placed for QT3000! OK?";
		// \D*:非数字字符匹配   \d+: 数字字匹配   .*:匹配多个字符
		String pattern = "(\\D*)(\\d+)(.*)";
		/* \\D*:实际上是\d，因为Java中\是转义字符前导符，
		 * 所以【在字符串中书写\】必须得写成\\才能正确识别，
		 * 所以正则表达式中的\d就表示为\\d的。
		*/
		
		// 创建Pattern对象
		Pattern r = Pattern.compile(pattern);
		// 创建matcher对象
	    Matcher m = r.matcher(line);
	    // 查看表达式分组数( group(0)默认不包括在内 )
	    System.out.println("分组数:" + m.groupCount());
        //public boolean find()
	   //尝试查找与该模式匹配的输入序列的下一个子序列。
	    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");
	    }
	    
	}

}

 

       

 

  

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

package regex;

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

public class Start_End {
	// 匹配一个边界cat  如 catbbb 、 bbbcat 、  b catb 、 cat b  但是不匹配 bcatb  
	private static final String REGEX = "\\bcat\\b";
	private static final String CONTENT= "cat cat cat cattie cat";
	
	public static void main(String[] args) {
		//Pattern： 一个Pattern是一个正则表达式经编译后的表现模式。 
        //Matcher： 一个Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查
		// boolean matches()    尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。
		Pattern p = Pattern.compile(REGEX);
		Matcher m = p.matcher(CONTENT);
		int count = 0;
		while(m.find()) {
			count++;
			System.out.println("Matcher number:" + count);
			System.out.println("start()" + m.start());
			System.out.println("end()" + m.end());
		}
		
	}

}

matches 和 lookingAt 方法

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

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

这两个方法经常在输入字符串的开始使用。

我们通过下面这个例子，来解释这个功能：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    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 替换所有匹配。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    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);
   }
}

 

  matches() 方法用于检测字符串是否完全匹配给定的正则表达式