Java正则表达式

Java提供了java.util.regex包，用于与正则表达式进行模式匹配。 Java正则表达式与Perl编程语言非常相似，并且非常易于学习。

正则表达式是特殊的字符序列，可以使用模式中保留的特殊语法来帮助你匹配或查找其他字符串或字符串集。它们可用于搜索，编辑或处理文本和数据。

java.util.regex软件包主要包含以下三个类：

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

• 配对类：Matcher对象是解释模式并针对输入字符串执行匹配操作的引擎。与Pattern类一样，Matcher也没有定义公共构造函数。你可以通过调用Matcher()Pattern对象上的方法。

• 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 line = "This order was placed for QT3000! OK?";
        String pattern = "(.*)(\\d+)(.*)";

        //创建一个Pattern对象
        Pattern r = Pattern.compile(pattern);

        //现在创建匹配器对象。
        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类的方法

以下是有用的实例方法的列表：

索引方法

索引方法提供有用的索引值，这些值精确显示在输入字符串中找到匹配项的位置：

查找方法

查找方法检查输入的字符串并返回一个布尔值，指示是否找到该模式：

替换方法

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

起始和结束方法

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

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);   //获取匹配对象
        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方法

match和lookingAt方法都尝试将输入序列与模式进行匹配。但是，区别在于匹配要求整个输入序列都必须匹配，而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);
      
        //获取匹配对象
        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);
      
        //获取匹配对象
        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类提供了以下方法来帮助你确定出了什么问题：