带有正则表达式的 java 正则表达式

正则表达式是描述字符序列中的模式的字符串。您可以使用 API 正则表达式 for：

验证字符序列，例如，检查电子邮件或密码的有效性;
在 a 字符串;
替换 String 中的模式或字符集。

API java.util.regex 有一个接口和三个类：

Pattern class：正则表达式的编译表示形式。要创建模式，必须调用其方法之一 public static compile，这将返回一个 Pattern 对象。这些方法接受正则表达式作为参数。

Matcher class：解析字符串的模式搜索引擎。通过调用 Pattern 对象中的 Matcher 方法获取 Matcher 对象。这两个类一起工作。

PatternSyntaxException：当正则表达式无效时抛出异常。

Matcher class

Matcher：

No.	方法	描述
1	boolean matches（）	如果字符串检查模式，则返回 true
2	boolean find（）	查找下一个检查模式的表达式
3	boolean find（int start）	查找从起始索引检查模式的下一个表达式

Pattern 类

这是正则表达式的编译版本。它用于模式或正则表达式.

No.	方法	Description
1	static Pattern compile（String regex）	编译正则表达式并返回 Pattern
2	Matcher matcher（CharSequence input）	创建一个解析输入序列的匹配器
3	static boolean matches（String regex， CharSequence input）	编译和解析输入序列。
4	String[] split（CharSequence c）	返回以字符 c
5	String pattern（）	返回正则表达式字符串

Example

import java.util.regex.*;

public class regexTest {

 public static void main（String args[]） {
 模式 p;
 Matcher m;
 //使用模式编译正则表达式：a”
 p = Pattern.compile（a”）;
 //创建引擎，并将引擎与字符串 ab”
 m = p.matcher（ab”）;
 //如果找到模式
 if（m.find（）） {
 System.out.println（找到模式”）;
 }
 }
}

找到模式

正则表达式语法

1- 元字符

元字符是具有某种含义或以其他方式的字符，模式是如何构建的。例如，如果在元字符前面加上字符，解析器不会解释它。java正则表达式支持的元字符如下表所示：

字符	描述
[ ]	定义
{ }	Quantizer
\	字符不被视为元字符
^	行首
$	Endline
\|	Operator OU
？	0 或前面的表达式
*	0 或前面表达式
+	前面表达式的一次或多次
.	替换任何字符

示例：

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

public class metaCharactersExample： {

 public static void main（String[] args） {
 System.out.println（
 Pattern.matches（.c”， abc”））;//false （. 仅替换 a） 
 System.out.println（
 Pattern.matches（..c， ”abc））;//true （第 3 个字符为 c）
 System.out.println（
 Pattern.matches（”...c， ”abbc））;//true （第 4 个字符为 c）
 
 System.out.println（Pattern.matches（”\\d， ”2））;//true （只有一个数字）
 System.out.println（Pattern.matches（”\\d， ”332））;//false （多位数字） 
 System.out.println（Pattern.matches（
 ”\\d，”123abc））;//false （数字和字符）
 
 System.out.println（Pattern.matches（
 ”\\D*， geek”））;//true （未加密，至少出现一次） 
 }
}

The matches（）属于 Matcher 和 Pattern 类，返回 true 如果要查找的模式存在于 string.

2- 字符类

字符类是一组字符。元字符 [...] 表示正则表达式中的字符类。您可以使用连字符 '-'。例如[0-9] 表示从 0 到 9 的数字.

[abc]	a、b 或 c
[^abc]	否定：替换除 a、b 和 c
[a-zA-Z]	范围：替换从 a 到 z 和从 A 到 Z
[a-d[m-p]]	Union：将 a 替换为 d 或从 m 替换为 p：[a-dm-p]
[a-z&&[美国广播公司]]	Intersection：将 a、b 和 c 的整个交集替换为 a 到 z
[a-z&&[^cd]]	减法：替换除 c 和 d 之外从 a 到 z 的所有字符：[abe-z]
[a-z&&[^m-p]]	减法：从 a 到 z，除了从 m 到 p：[a-lq-z]

Example

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

public class metaFeaturesExample： {

 public static void main（String[] args） {
 Pattern p;
 Matcher m;
 //从 0 到 9 的所有数字，除了 345
 p = Pattern.compile（[0-9&&[^345]]）;
 m = p.matcher（7”）;
 布尔值 b = m.matches（）;
 System.out.println（b）;
 }
}

true

Predefined character classes

这些是 Java：

除数字 [^0-9]

类	描述
.	任意字符
\d	一个数字：[0-9]
\D
\s	空白字符：换行符，空格：[ \t\n\x0B\f\r]
\S	非白色字符： [^\s]
\w	单词字符： [a-zA-Z_0-9]
\W	不是单词的字符： [^\w]

Example

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

public class CharacterClassesExample{
 public static void main（String args[]） {
 //d： 1 位 
 //+： 1 位或更多位
 字符串正则表达式 = \\d+”;
 模式 p = Pattern.compile（regex）;

 字符串短语 = 2015 21 年”;
 
 匹配器 m = p.matcher（句子）;

 if （m.find（）） {
 //show first group
 System.out.println（group 0：” + m.group（0））;
 }
 }
}

group 0：2015

在此示例中，正则表达式 \\d+ 包含两个斜杠，因为在 Java 中，您总是添加一个 '\ 之前。\d 表示介于 0 和 9 之间的范围如果删除 '+ ，仅考虑找到的第一个数字：2.

3- 量词

量化器允许您设置字符重复的次数。

量化器	描述
X？	X 出现不超过一次
X+	一次或多次
X*	零次或多次
X{n}	n times
X{n，}	n 或多次
X{y，z}	至少 y 次但小于 z 次

示例

Motif	String	结果
[abc]？	a	a
[abc]？	aa	none
[abc]？	ab	none
a？	abdaaaba	{a}，{ }，{ }，{a}，{a}，{a}，{ }，{a}
a*	abdaaaba	{a}，{ }，{ }，{ }，{aa}，{a}
a+	abdaaaba	{a}，{aaa}，{a}
a[3]	aaaa	aaa
a{3， 6}	aaaaaaaa	aaaaaa
[0-9]{4}	2038 年的 bug 类似于 2000 年的 bug	{2038}， {2000}

4- 捕获组

捕获组提供了处理多个字符的能力作为单个单元或子模式。例如，（abc）创建一个包含字符的组 a”、b”和c”.

渔获组按从左到右打开的括号数计算。在表达式（A（B（C））），有4组。组 0 始终包含整个表达式：

第0组：（A（B（C）））

第1组：（A）

组2：（B（C））

第3组：（C）

要在 Java 中找出表达式中有多少个组，请调用方法 groupCount（）。groupCount（）返回 int表示组总数。在以下示例中，goupCount（）将返回数字 4.

组捕获的子字符串由 group（int）.

示例 1：

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

public class Goup {

 public static void main（String[] args） {

 Pattern p = Pattern.compile（（A（B（C）））”）;
 匹配器 m = p.matcher（ABC”）;
 if（ m.matches（））
 for（int i= 0; i<= m.groupCount（）; ++i）
 System.out.println（组 ”+i+ ：”+m.group（i））;
 
 }
}

group 0：ABC
group 1：ABC
group 2：BC
group 3：C

示例 2

此程序创建一个正则表达式，用于读取和检查电话号码的有效性：

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

public class regex_telephone {
 
 public static void main（String[] args） {
 
 String regex = \\b（\\d{3}）（\\d{4}）（\\d{3}）（\\d{3}）\\b”;
 模式 p = Pattern.compile（regex）;
 字符串 tel = 2541724156348”;
 
 匹配器 m = p.matcher（tel）;
 
 if （m.find（）） {
 System.out.println（电话： （”
 + m.group（1） + ） ” + m.group（2） + -” 
 + m.group（3） + -” + m.group（4））;
 } 
 }
}

电话： （254） 1724-156-348

5- 搜索边界

您可以通过指定要查找的模式的位置及其开始位置来使模式更精确。

Word End.

limiter	描述
^	行首
$	Endline
\b
\B	Non-Word End.
\A	输入序列开始
\G	上次出现的结束
\Z	序列结束，最后一个字符除外
\z	序列结束

示例

Motif	String	结果
^java$	java	java
\s*java$	java	java
^hello\w*	helloblahblah	helloblahblah
\bjava\B	javascript 是一种编程语言	java
\Gtest	test test	test
\btest\b	这是一个测试	test

查找模式并替换它

正则表达式 API 使您能够查找一个文本并将其替换为另一个文本。在 Java 中，可以使用 Matcher 类的两种方法来完成此任务：

replaceFirst（String）：仅替换第一个出现项;
replaceAll（String）：迭代并替换所有出现项。

Example：

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

public class 替换 {
 public static void main（String[] args） {
 Pattern p = Pattern.compile（bus”）;
 Matcher m = p.matcher（我乘公共汽车旅行”）;
 字符串 s = m.replaceAll（train”）;
 System.out.println（s）;
 }
}

我乘火车旅行

参考：
Java 文档：正则表达式
JavaPoint： Java 正则表达式
TutorialsPoint： Java - 正则表达式
展开：使用 Java