正则表达式-Java实现-\s、\S、{ }、{n,}、\b、\B
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了正则表达式-Java实现-\s、\S、{ }、{n,}、\b、\B，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含4995字，纯文字阅读大概需要8分钟。
内容图文
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
匹配空格，空格的内容有：退回[\b]、换页\f、回车\r、换行\n、制表符（Tab键，水平制表符）\t、垂直制表符\v
windows 中 \r\n 是文本行结束标签，在 linux 中是 \n
所以在匹配一行空格的时候，在 Windows中是 \r\n\r\n 也就是上一行结束，下一行也结束，在 Linux 中是 \n\n
\s 任何一个空白字符，等价于 [\f\r\n\t\v] ,用来匹配退格字符 [\b] 是一个特例；它不再类元字符 \s 中
\S 任何一个非空白字符，等价于 [^\f\r\n\t\v]
*/
public class MatchSpace {
public static void main(String[] args) {
Pattern p = Pattern.compile("\\r\\n\\r\\n");
String str = "\"101\",\"Bea\", \"Forta\"\r\n" +
"\"102\",\"Jim\", \"James\"\r\n" +
"\r\n"+
"\"103\",\"Roberta\", \"Robertson\"\r\n" +
"\"104\",\"Bob\", \"Bobson\"\r\n";
System.out.println(str);
Matcher m = p.matcher(str);
System.out.print("start");
int i = 1;
while (m.find()){
System.out.println(m.group());
}
System.out.println("end");
/*
"101","Bea", "Forta"
"102","Jim", "James"
"103","Roberta", "Robertson"
"104","Bob", "Bobson"
*/
//这个空白匹配，在 Windows 中是 \r\n\r\n 在 Linux 中是 \n\n
//也就是说\r是一个可选的内容
// [\r]?\n[\r]?\n
}
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
{ 和 } 确定重复次数
可以使用 { } 来给重复设置一个区间，也就是为重复匹配次数设定一个最大值和一个最小值
{2, 4} 的含义是最少重复2次，最多重复4次
{ } 语法设定区间的时候可以只给出一个最小值 {3,} 意思是至少重复 3 次
*/
public class RepeatMatch4{
public static void main(String[] args){
String str = "<body bgcolor=\"#336633\" text=\"#FFFFFF\" marginwidth=\"0\" marginheight=\"0\" topmargin=\"0\" leftmargin=\"0\">";
Pattern p = Pattern.compile("#[A-Fa-f0-9]{6}");
Matcher m = p.matcher(str);
while (m.find()){
System.out.println(m.group());
}
/*
#336633
#FFFFFF
*/
String str2 = "4/8/03 10-6-2004 2/2/2 01-01-01";
// 匹配日期 \d{1, 2}[\-/]\d{1, 2}[\-/]\d{2, 4}
// 当使用 [-\/] 进行匹配的时候，在 Pattern.compile() 里面写成 [-\//] 会抛出异常
// java.util.regex.PatternSyntaxException
// 改成 [-\\/] 也就是先匹配 \ 就不会抛出异常，也可以这样 [-/\\\\] 也就是从 - / \ \ 中任意匹配一个个
// 功能是一样的
p = Pattern.compile("\\d{1,2}[-\\/]\\d{1,2}[-\\/]\\d{2,4}");
m = p.matcher(str2);
System.out.println(m.pattern());
while (m.find()){
System.out.println(m.group());
}
/*
4/8/03
10-6-2004
01-01-01
*/
System.out.println();
String str3 = "1001: $496.80 1002: $1290.69 1003: $26.43 1004: $613.42 1005: 7.61 1006: 414.90 1007: 25.00";
// \d+: \$\d{3,}\.\d{2}
p = Pattern.compile("\\d+: \\$\\d{3,}\\.\\d{2}");
m = p.matcher(str3);
System.out.println(m.pattern()); // \d+: \$\d{3,}\.\d{2}
while (m.find()){
System.out.println(m.group());
}
/*
1001: $496.80
1002: $1290.69
1004: $613.42
*/
}
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
防止过度匹配，“贪婪型”的字符 + * { }
将“贪婪型”的字符转换成“懒惰型”的字符，只需要在“贪婪型”的字符后面添加一个 ? 就可以了
贪婪型 懒惰型
* *?
+ +?
{n,} {n,}?
*/
public class RepeatMatch5{
public static void main(String[] args){
String str = "This offer is not avaliable to customers living in <B>AK</B> and <B>HI</B>";
// + 和 * 都是贪婪型的，也就是尽量匹配多的字符
// 匹配标签<B> <[Bb]>.*<[Bb]>
Pattern p = Pattern.compile("<[Bb]>.*</[Bb]>");
Matcher m = p.matcher(str);
System.out.println(m.pattern()); //<[Bb]>.*</[Bb]>
while (m.find()){
System.out.println(m.group());
}
// <B>AK</B> and <B>HI</B>
//可以看出此时匹配出来的内容很多，并没有是一个完整的<B>标签
System.out.println();
// 懒惰型 <[Bb]>.*?</[Bb]>
p = Pattern.compile("<[Bb]>.*?</[Bb]>");
m = p.matcher(str);
System.out.println(m.pattern()); // <[Bb]>.*?</[Bb]>
while (m.find()){
System.out.println(m.group());
}
/*
<B>AK</B>
<B>HI</B>
*/
}
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/*
\b boundary 单词边界匹配，\b 匹配的位置是一个能过够用来构成单词的字符（字母、数字和下划线，也就是 \w）
和一个不能用来构成单词的字符（也就是 \W）
需要注意的是，在使用 \b 进行字符的边界匹配的时候，单词的前后都需要有 \b
\B 与 \b 相反的功能
*/
public class BoundaryMatch{
public static void main(String[] args){
String str = "The cat scattered his food all over the room.";
//将 cat 匹配出来， cat
Pattern p = Pattern.compile("cat");
Matcher m = p.matcher(str);
while (m.find()){
System.out.println(m.group());
}
/*
cat
cat
*/
//将scattered中的cat也匹配出来了，显然不是想要的，需要的是一个单词的匹配
System.out.println();
//使用的正则表达式 \bcat\b
p = Pattern.compile("\\bcat\\b");
m = p.matcher(str);
System.out.println(m.pattern());
while (m.find()){
System.out.println(m.group());
}
//cat
System.out.println();
String str2 = "Please enter the nine-digit id as it appers on your color - coded pass-key.";
//找出字符串中字符 - 前后有多余空格的 -
// \B-\B 因为 - 不属于 \w 也就是说它不能构成单词，所以本身就是一个单词边界
p = Pattern.compile("\\B-\\B");
m = p.matcher(str2);
String result = m.replaceAll("&");
System.out.println(result);
// Please enter the nine-digit id as it appers on your color & coded pass-key.
System.out.println();
p = Pattern.compile("\\b-\\b");
m = p.matcher(str2);
result = m.replaceAll("&");
System.out.println(result);
//Please enter the nine&digit id as it appers on your color - coded pass&key.
}
}
内容总结
以上是互联网集市为您收集整理的正则表达式-Java实现-\s、\S、{ }、{n,}、\b、\B全部内容，希望文章能够帮你解决正则表达式-Java实现-\s、\S、{ }、{n,}、\b、\B所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】