Java中的正则表达式 - Java Regex示例

 

Java中的正则表达式 - Java Regex示例

 

欢迎使用Java中的正则表达式。它在Java中也称为Regex。当我开始编程时，java正则表达式对我来说是一场噩梦。本教程旨在帮助您掌握Java中的正则表达式。我也会回到这里刷新我的Java Regex学习。

 

目录[ 隐藏 ]

• 1 Java中的正则表达式
  • 1.1 Java中的正则表达式 - 常用匹配符号
  • 1.2 Java Regex元字符
  • 1.3 Java中的正则表达式 - 量词
  • 1.4 Java中的正则表达式 - 捕获组

 

Java中的正则表达式

java中的正则表达式定义了String的模式。正则表达式可用于搜索，编辑或操作文本。正则表达式不是特定于语言的，但它们对于每种语言略有不同。Java中的正则表达式与Perl最相似。

Java Regex类java.util.regex包含在包含三个类的包中：

1. Pattern：Patternobject是正则表达式的编译版本。Pattern类没有任何公共构造函数，我们使用它的公共静态方法compile通过传递正则表达式参数来创建模式对象。
2. Matcher：Matcher是java regex引擎对象，它将输入String模式与创建的模式对象进行匹配。Matcher类没有任何公共构造函数，我们使用模式对象matcher方法获取Matcher对象，该方法将输入String作为参数。然后我们使用matches返回基于输入的布尔结果的方法。字符串是否匹配正则表达式模式。
3. PatternSyntaxException：PatternSyntaxException如果正则表达式语法不正确，则抛出此异常。

我们来看看Java Regex示例程序。

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// bad regular expression
		pattern = Pattern.compile("*xx*");

	}

}

当我们运行这个java正则表达式示例程序时，我们得到低于输出。

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

由于java正则表达式围绕String，因此在Java 1.4中扩展了String类，以提供一种matches 执行正则表达式模式匹配的方法。在内部，它使用Pattern和Matcherjava正则表达式类进行处理，但显然它减少了代码行。

Patternclass还包含matches接受正则表达式并输入String作为参数的方法，并在匹配后返回布尔结果。

所以下面的代码可以很好地匹配输入String和Java中的正则表达式。

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

因此，如果您的要求只是检查输入String是否与模式匹配，则应使用简单的String匹配方法来节省时间和代码行。

只有在需要操作输入String或者需要重用模式时才应使用Pattern和Matches类。

请注意，正则表达式定义的模式从左到右应用于字符串，一旦在匹配中使用源字符，就无法重用。

例如，正则表达式“121”将仅匹配“31212142121”两次“_121____121”。

 

Java中的正则表达式 - 常用匹配符号

正则表达式	描述	例
。	匹配任何单个字符	（“..”，“a％”） - 真（“..”，“。a”） - 是的   （“..”，“a”） - 错误
^ XXX	在行的开头匹配xxx正则表达式	（“^ ac”，“abcd”） - 是的   （“^ a”，“ac”） - false
XXX $	在行尾匹配正则表达式xxx	（“.. cd $”，“abcd”） - true（“a $”，“a”） - 是的   （“a $”，“aca”） - 假
[ABC]	可以匹配任何字母a，b或c。[]称为字符类。	（“^ [abc] d。”，“ad9”） - true（“[ab] .d $”，“bad”） - true   （“[ab] x”，“cx”） - false
[ABC] [12]	可以匹配a，b或c后跟1或2	（“[ab] [12]。”，“a2＃”） - true（“[ab] .. [12]”，“acd2”） - true   （“[ab] [12]”，“c2”） - 错误
[^ ABC]	当^是[]中的第一个字符时，它会否定模式，匹配除a，b或c之外的任何内容	（“[^ ab] [^ 12]。”，“c3＃”） - true（“[^ ab] .. [^ 12]”，“xcd3”） - true   （“[^ ab] [^ 12]”，“c2”） - 假
[A-E1-8]	匹配范围在a到e或1到8之间	（“[a-e1-3]。”，“d＃”） - 真（“[a-e1-3]”，“2”） - 真   （“[a-e1-3]”，“f2”） - 错误
XX | YY	匹配正则表达式xx或yy	（“x。| y”，“xa”） - true（“x。| y”，“y”） - true（“x。| y”，“yz”） - false

 

Java Regex元字符

我们在Java正则表达式中有一些元字符，它就像常见匹配模式的短代码。

正则表达式	描述
\ d	任何数字，短于[0-9]
\ d	任何非数字，[^ 0-9]的缩写
\ S	任何空白字符，[\ t \ n \ x0B \ f \ r]的缩写
\ S	任何非空白字符，[^ \ s]的缩写
\ W	任何单词字符，[a-zA-Z_0-9]的缩写
\ W	任何非单词字符，[^ \ w]的缩写
\ b	一个词边界
\乙	非字边界

在正则表达式中，有两种方法可以将元字符用作普通字符。

1. 使用反斜杠（\）在元字符之前。
2. 将metacharcter保持在\ Q（开始引用）和\ E（结束它）内。

 

Java中的正则表达式 - 量词

Java Regex Quantifiers指定要匹配的字符的出现次数。

正则表达式	描述
X？	x发生一次或根本不发生
X*	X出现零次或多次
X +	X出现一次或多次
X {N}	X恰好出现n次
X {N，}	X出现n次或更多次
X {N，M}	X出现至少n次但不多于m次

Java Regex Quantifiers也可以与字符类和捕获组一起使用。

例如，[abc] +表示 - a，b或c - 一次或多次。

（abc）+表示组“abc”多一次。我们现在将讨论捕获组织。

 

Java中的正则表达式 - 捕获组

Java中的正则表达式捕获组用于将多个字符视为单个单元。您可以使用创建组()。与捕获组匹配的输入String部分将保存到内存中，并可使用Backreference进行调用。

您可以使用matcher.groupCount方法查找java正则表达式模式中的捕获组数。例如，（（a）（bc））包含3个捕获基团 - （（a）（bc）），（a）和（bc）。

您可以使用反斜杠（\）在正则表达式中使用反向引用，然后使用要调用的组的编号。

捕获组和反向引用可能会令人困惑，所以让我们通过一个例子来理解这一点。

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

在第一个示例中，在运行时，第一个捕获组是（\ w \ d），当与输入字符串“a2a2”匹配时，它评估为“a2”并保存在内存中。所以\ 1指的是“a2”，因此它返回true。由于同样的原因，第二个语句打印错误。

尝试自己理解语句3和4的这种情况。 

现在我们来看一下Pattern和Matcher类的一些重要方法。

1. 我们可以使用flags创建一个Pattern对象。例如，Pattern.CASE_INSENSITIVE启用不区分大小写的匹配。
2. Pattern类还提供split(String)类似于String类split()方法的方法。
3. Pattern类toString()方法返回从中编译此模式的正则表达式String。
4. 匹配器类有start()和end()索引方法可以精确显示在匹配的输入字符串中找到。
5. Matcher类还提供了String操作方法replaceAll(String replacement)和  replaceFirst(String replacement)。

让我们在一个简单的示例程序中查看这些java正则表达式方法。

package com.journaldev.util;

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

public class RegexExamples {

	public static void main(String[] args) {
		// using pattern with flags
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// using Matcher find(), group(), start() and end() methods
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// using Pattern split() method
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		// using Matcher.replaceFirst() and replaceAll() methods
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

上面的java正则表达式示例程序的输出是。

Copy

Found the text "AB" starting at 0 index and ending at index 2 Found the text "ab" starting at 3 index and ending at index 5 Found the text "Ab" starting at 6 index and ending at index 8 Split using Pattern.split(): one Split using Pattern.split(): two Split using Pattern.split(): three Split using Pattern.split(): four Split using Pattern.split(): five Using replaceAll: _345_678 Using replaceFirst: _34512678

这就是Java中正则表达式的全部内容。Java Regex起初看起来很难，但如果你使用它们一段时间，它就很容易学习和使用。

 

转载来源：https://www.journaldev.com/634/regular-expression-in-java-regex-example