Java正则表达式

Java提供了java.util.regex包的模式正则表达式匹配。 Java正则表达式是非常相似的Perl编程语言，很容易学习。

正则表达式是一个字符的特殊序列，可以帮助您匹配或查找其他字符串或字符串集，使用的模式举行了专门的语法。它们可以被用于搜索，编辑或处理文本和数据。

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

• Pattern 类: Pattern对象是一个正则表达式的编译表示。 Pattern类不提供公共构造函数。要创建一个模式，必须首先调用其公共静态编译的方法之一，这将返回一个Pattern对象。这些方法接受一个正则表达式作为第一个参数。

• Matcher 类: Matcher对象是解释模式，并执行对输入字符串匹配操作的引擎。像Pattern类，匹配器定义没有公共的构造函数。通过调用一个Pattern对象的匹配方法获得一个Matcher对象。

• PatternSyntaxException: PatternSyntaxException对象是一个未经检查的异常，表明正则表达式模式中的语法错误.

捕获组：

捕获组是一种方法处理多种字符作为一个单一的单元。他们被放置到一组括号内分组字符创建。例如，正则表达式（dog）创建一个包含字母"d", "o" 和  "g" 的一个组。 .

捕获组是由左至右计数的左括号的编号。例如，表达式((A)(B(C)))有四个这样的组：

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

• (A)

• (B(C))

• (C)

要找出有多少组出现在表达式，调用一个匹配对象的groupCount方法。groupCount方法返回一个int表示目前在匹配器模式的捕获组数.

还有一个特别的组，组0，它始终代表整个表达式。此组中不包括所报告groupCount的总和。

例子：

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

 import java.util.regex.Matcher; import java.util.regex.Pattern;  public class RegexMatches {     public static void main( String args[] ){        // String to be scanned to find the pattern.       String line = "This order was placed for QT3000! OK?";       String pattern = "(.*)(//d+)(.*)";        // Create a Pattern object       Pattern r = Pattern.compile(pattern);        // Now create matcher object.       Matcher m = r.matcher(line);       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) );       } else {          System.out.println("NO MATCH");       }    } }

这将产生以下结果:

 Found value: This order was placed for QT3000! OK? Found value: This order was placed for QT300 Found value: 0 

正则表达式语法

这里的表中列出了所有的正则表达式元字符，并可在Java中的语法：

Matcher 类的方法:

这里是一个有用的实例方法的列表：

index方法：

索引方法提供了精确显示的地方找到匹配输入字符串有用的索引值：

Study方法:

研究方法的检讨输入字符串，并返回一个Boolean值，指示模式是否发现：

Replace方法：

替代的方法是在输入字符串替换文本有用的方法：

start 和 end 方法:

以下是计算的次数的单词 "cats"出现在输入字符串中的示例： 

 import java.util.regex.Matcher; import java.util.regex.Pattern;  public class RegexMatches {     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); // get a matcher object        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方法将返回以前匹配操作期间由给定组捕获的子序列的起始索引和结束返回匹配的最后一个字符的索引加一。

matches 和 lookAt 方法：

匹配和寻找方法都试图用模式匹配的输入序列。差别是：匹配要求整个输入序列进行匹配，而寻找没有。

这两种方法总是从输入字符串的开始位置。下面是示例说明它的功能：

 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 Pattern pattern;     private static Matcher matcher;      public static void main( String args[] ){        pattern = Pattern.compile(REGEX);        matcher = pattern.matcher(INPUT);         System.out.println("Current REGEX is: "+REGEX);        System.out.println("Current INPUT is: "+INPUT);         System.out.println("lookingAt(): "+matcher.lookingAt());        System.out.println("matches(): "+matcher.matches());    } }

这将产生以下结果:

 Current REGEX is: foo Current INPUT is: fooooooooooooooooo lookingAt(): true matches(): false

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);    } }

这将产生以下结果:

 The cat says meow. All cats say meow.

appendReplacement 和 appendTail 方法:

Matcher 类还提供appendReplacement和appendTail方法文本替换。

下面是示例说明它的功能：

 import java.util.regex.Matcher; import java.util.regex.Pattern;  public class RegexMatches {    private static String REGEX = "a*b";    private static String INPUT = "aabfooaabfooabfoob";    private static String REPLACE = "-";    public static void main(String[] args) {       Pattern p = Pattern.compile(REGEX);       // get a matcher object       Matcher m = p.matcher(INPUT);       StringBuffer sb = new StringBuffer();       while(m.find()){          m.appendReplacement(sb,REPLACE);       }       m.appendTail(sb);       System.out.println(sb.toString());    } }

这将产生以下结果:

 -foo-foo-foo-

PatternSyntaxException 类方法：

PatternSyntaxException是一个未经检查的异常，表明正则表达式模式中的语法错误。PatternSyntaxException类提供以下方法来帮助确定什么地方出了错：