边肖将与大家分享如何在Java正则表达式中实现分组和替换。希望大家看完这篇文章后有所收获。我们一起讨论一下吧！
正则表达式的子表达式(分组)不容易理解，但它们是强大的文本处理工具。
00-1010
1 正则表达式热身
//电话号码匹配
//手机号段只有13 xxx15 XXX 18 xxxx 17 xx。
system . out . println(' 18304072984 '。匹配(' 1[3578]\ \ d { 9 } ')；//真
//座机号码：010-65784236、0316-3312617、022-12465647、0312 3312336
stringlex=' 0 \ \ d { 2 }-？\\d{8}|0\\d{3}-？\ \ d { 7 } '；
StringtelStr=' 010-43367458 '；
system . out . println(TelStr . matches(regex))；//true
匹配电话号码
Stringmail=' I @ jiaobuchong.com . cn '；
string Greg='[a-Za-Z _ 0-9]@[a-Za-Z0-9](\ \。[a-zA-Z] ){1，2 } '；
system . out . println(mail . matches(reg))；//true
匹配邮箱
用空格替换非汉字：
Stringinput='侦探*% $杰四天王@ bdfbdbdfdgds 23532 '；
stringreg='[^\\u4e00-\\u9fa5]'；
input=input . replace all(reg ' ')；
System.out.println(输入)；//迪徐人杰侦探四大天王汉字的Unicode编码范围为：\u4e00-\u9fa5
00-1010组是用括号分开的正则表达式，可以根据一个组的编号来指代该组。组号0代表整个表达式，组号1代表第一对括号展开的组，依此类推。
看 Java API 中 Pattern 中的描述：
捕获组通过从左到右计算它们的左括号来编号。例如，在表达式((A)(B(C))中，有四个这样的组：
1.((甲)(乙(丙)))
2.(一)
3.(乙(丙))
4.(三)
比如A(B(C))D有三组：组0是ABCD，组1是BC，组2是C，
根据左括号的数量可以确定多少组，括号中的表达式都称为子表达式。
Eg1：
Matcher对象提供了许多方法：
GoupCount()返回正则表达式模式中的数据包数量，对应于“左括号”的数量
Group(int i)返回相应组的匹配字符，如果不匹配，则返回null。
Start(int group)返回相应组的匹配字符的起始索引。
End(int group)返回最后一个字符索引加上相应组的一个匹配字符的值。
//这个正则表达式有两组。
//组(0)是\ \ $ \ \ {([{}]？)\\}
//gr
oup(1) 是 ([^{}]+?)
String regex = "\\$\\{([^{}]+?)\\}";
Pattern pattern = Pattern.compile(regex);
String input = "${name}-babalala-${age}-${address}";
Matcher matcher = pattern.matcher(input);
System.out.println(matcher.groupCount());
// find() 像迭代器那样向前遍历输入字符串
while (matcher.find()) {
System.out.println(matcher.group(0) + ", pos: "
+ matcher.start() + "-" + (matcher.end() - 1));
System.out.println(matcher.group(1) + ", pos: " +
matcher.start(1) + "-" + (matcher.end(1) - 1));
}
输出：
1
${name}, pos: 0-6
name, pos: 2-5
${age}, pos: 17-22
age, pos: 19-21
${address}, pos: 24-33
address, pos: 26-32
group翻译成中文就是分组。
group()或group(0)对应于整个正则表达式每次匹配到的内容，
group(1)表示括号中(一个子表达式分组)匹配到的内容。
Eg2：
为了更直观的看分组，在 Eg1 的正则表达式上再多加一对括号：
String regex = "(\\$\\{([^{}]+?)\\})";
Pattern pattern = Pattern.compile(regex);
String input = "${name}-babalala-${age}-${address}";
Matcher matcher = pattern.matcher(input);
// matcher.find() 方法会对 input 这个字符串多次进行匹配，如果能匹配到，这个匹配结果里就会包含多个分组，我们可以从分组里提取我们想要的结果
while (matcher.find()) {
System.out.println(matcher.group(0) + ", pos: " + matcher.start());
System.out.println(matcher.group(1) + ", pos: " + matcher.start(1));
System.out.println(matcher.group(2) + ", pos: " + matcher.start(2));
}
输出：
${name}, pos: 0
${name}, pos: 0
name, pos: 2
${age}, pos: 17
${age}, pos: 17
age, pos: 19
${address}, pos: 24
${address}, pos: 24
address, pos: 26
由此可得出一对括号一个分组，可以通过左括号数来确定有多少个分组。
通过group()获取分组中的匹配字串应用场景很广泛，
在笔者的一个项目中，通过使用这个特性实现了很有意思的通配符替换，感动！
Eg3（通过分组提取想要的数据）:
// 这个正则表达式会提取字符串中的「数字」和「字母」
Pattern pattern = Pattern.compile("([0-9]+).*?([a-zA-Z]+)");
String input = "那就20200719这样吧sunny。。。。。。。122432该拿什么与眼泪抗衡twinkle";
Matcher matcher = pattern.matcher(input);
// 每个匹配到的子串分组的个数
int group = matcher.groupCount();
// 如果输入串有多个可被匹配的子串，这里会多次进行匹配
while (matcher.find()) {
System.out.println("匹配到的子串：" + matcher.group()); // 匹配到的子串
for (int i = 1; i <= group; i++) {
System.out.println("分组" + i + ": " + matcher.group(i));
}
}
输出：
匹配到的子串：20200719这样吧sunny
分组1: 20200719
分组2: sunny
匹配到的子串：122432该拿什么与眼泪抗衡twinkle
分组1: 122432
分组2: twinkle
3 分组替换
Eg1：
String tel = "18304072984";
// 括号表示组，被替换的部分$n表示第n组的内容
tel = tel.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
System.out.print(tel); // output: 183****2984
replaceAll 是一个替换字符串的方法，正则表达式中括号表示一个分组，replaceAll 的参数 2 中可以使用 $n（n 为数字）来依次引用子表达式中匹配到的分组字串，"(\\d{3})\\d{4}(\\d{4})", "$1****$2"，分为前（前三个数字）中间四个数字(最后四个数字) 替换为（第一组数字保持不变 $1）（中间为 * ）（第二组数字保持不变 $2）。
Eg2：
String one = "hello girl hi hot".replaceFirst("(\\w+)\\s+(\\w+)", "$2 $1");
String two = "hello girl hi hot".replaceAll("(\\w+)\\s+(\\w+)", "$2 $1");
System.out.println(one); // girl hello hi hot
System.out.println(two); // girl hello hot hi
理解了Eg1，这个例子也自然就理解了。
Eg3：
来一个实用的例子，重复标点符号替换：
String input = "假如生活欺骗了你，，，相信吧，，，快乐的日子将会来临！！！…………"; // 重复标点符号替换 String duplicateSymbolReg = "([。？！?!，]|\\.\\.\\.|……)+"; input = input.replaceAll(duplicateSymbolReg, "$1"); System.out.println(input);
输出：
假如生活欺骗了你，相信吧，快乐的日子将会来临！……
正则表达式：([。？！?!，]|\\.\\.\\.|……)+，括号中是一个分组：表示一个标点符号，+表示这个分组出现一次或多次，$1分组的内容（一个标点符号）。replaceAll 就使用$1去对字符串进行替换了。
Eg4：
IP地址排序
String ip = "192.68.1.254 102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30";
ip = ip.replaceAll("(\\d+)", "00$1");
System.out.println(ip);
ip = ip.replaceAll("0*(\\d{3})", "$1");
System.out.println(ip);
String[] strs = ip.split(" ");
Arrays.sort(strs);
for (String str : strs) {
str = str.replaceAll("0*(\\d+)", "$1");
System.out.println(str);
}
输出：
00192.0068.001.00254 00102.0049.0023.00013 0010.0010.0010.0010 002.002.002.002 008.00109.0090.0030
192.068.001.254 102.049.023.013 010.010.010.010 002.002.002.002 008.109.090.030
2.2.2.2
8.109.90.30
10.10.10.10
102.49.23.13
192.68.1.254
-
让IP地址的每一段都是3位，替换之后有4位的情况
-
保证IP地址每一段都是3位
-
排序之
写到这里，笔者不禁感叹，真的很强大！
4 反向引用
使用小括号指定一个子表达式分组后，匹配这个子表达式的文本可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：以分组的左括号为标志，从左向右，第一个分组的组号为1，第二个为2，以此类推。
Eg：
/* 这个正则表达式表示 安安静静 这样的叠词 */
String regex = "(.)\\1(.)\\2";
System.out.println("安安静静".matches(regex)); // true
System.out.println("安静安静".matches(regex)); // false
上面 (.) 表示一个分组，里面 . 表示任意字符，每一个字符都是一个分组，
\\1表示组1（安）又出现了一次，\\2表示组2（静）又出现了一次。
那匹配 安静安静，怎么写正则表达式？根据上面的例子，将安静分成一个组，然后这个组又出现了一次就是安静安静：
String regex = "(..)\\1";
System.out.println("安静安静".matches(regex)); // true
System.out.println("安安静静".matches(regex)); // false
5 反向引用替换
Eg1：
String str = "我我...我我...我要..要要...要要...找找找一个....女女女女...朋朋朋朋朋朋...友友友友友..友.友...友...友友！！！";
/*将 . 去掉*/
str = str.replaceAll("\\.+", "");
System.out.println(str);
str = str.replaceAll("(.)\\1+", "$1");
System.out.println(str);
输出：
我我我我我要要要要要找找找一个女女女女朋朋朋朋朋朋友友友友友友友友友友！！！
我要找一个女朋友！
(.)表示任意一个字符都会成为一个分组；\\1+ 引用分组（一个字符），表示出现1次或多次这个分组。 $1引用分组(.)将多个重复字符替换成一个字符。
Eg2：
替换重复出现的两位数之间的内容：
"xx12abdd12345".replaceAll("(\\d{2}).+?\\1", ""); //结果为 xx345
是不是觉得很神奇！
使用replace系列的方法要注意的一个异常： Java replaceAll()方法报错Illegal group reference
看完了这篇文章，相信你对“Java正则表达式中如何实现分组和替换”有了一定的了解，如果想了解更多相关知识，欢迎关注行业资讯频道，感谢各位的阅读！
内容来源网络，如有侵权，联系删除，本文地址：https://www.230890.com/zhan/126940.html