共计 8757 个字符,预计需要花费 22 分钟才能阅读完成。
前言
正则表达式个别用于字符串匹配,字符串查找和字符串替换。别小看它的作用,在工作学习中灵活运用正则表达式解决字符串可能大幅度提高效率,编程的高兴来得就是这么简略。
上面将由浅入深解说正则表达式的应用。
简略入门 .
package test;
public class Test01 {public static void main(String[] args) {
// 字符串 abc 匹配正则表达式 "...", 其中 "." 示意一个字符
//"..." 示意三个字符
System.out.println("abc".matches("..."));
System.out.println("abcd".matches("..."));
}
}
输入后果:
true
false
String
类中有个 matches(String regex)
办法, 返回值为布尔类型,用于通知这个字符串是否匹配给定的正则表达式。
在本例中咱们给出的正则表达式为 ...
,其中每个.
示意一个字符,整个正则表达式的意思是三个字符,显然当匹配 abc
的时候后果为 true
,匹配abcd
时后果为false
。
Java 中对正则表达式的反对
在 java.util.regex
包下有两个用于正则表达式的类,一个是Matcher
,另一个Pattern
。
Java 官网文档中给出对这两个类的典型用法,代码如下:
package test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test02 {public static void main(String[] args) {//[a-z]示意 a~z 之间的任何一个字符, {3}示意 3 个字符, 意思是匹配一个长度为 3, 并且每个字符属于 a~z 的字符串
Pattern p = Pattern.compile("[a-z]{3}");
Matcher m1 = p.matcher("abc");
System.out.println(m2.matches());
}
}
输入后果:true
Pattern
能够了解为一个模式,字符串须要与某种模式进行匹配。比方 Test02
中, 咱们定义的模式是 一个长度为 3 的字符串, 其中每个字符必须是 a~z 中的一个
。
咱们看到创立 Pattern
对象时调用的是 Pattern
类中的 compile
办法,也就是说对咱们传入的正则表达式编译后失去一个模式对象。而这个通过编译后模式对象,,会使得正则表达式应用效率会大大提高,并且作为一个常量,它能够平安地供多个线程并发应用。
Matcher
能够了解为模式匹配某个字符串后产生的后果。字符串和某个模式匹配后可能会产生很多个后果,这个会在前面的例子中解说。
最初当咱们调用 m.matches()
时就会返回残缺字符串与模式匹配的后果。
下面的三行代码能够简化为一行代码:
System.out.println("abc".matches("[a-z]{3}"));
然而如果一个正则表达式须要被反复匹配,这种写法效率较低。
匹配次数符号
符号 | 次数 |
---|---|
* | 0 次或屡次 |
+ | 1 次或屡次 |
? | 0 次或 1 次 |
{n} | 恰好 n 次 |
{n,m} | 呈现 n~m 次 |
{n,} | 至多 n 次 |
代码示例:
package test;
public class Test03 {private static void p(Object o){System.out.println(o);
}
public static void main(String[] args) {
// "X*" 代表零个或多个 X
p("aaaa".matches("a*"));
p("".matches("a*"));
// "X+" 代表一个或多个 X
p("aaaa".matches("a+"));
// "X?" 代表零个或一个 X
p("a".matches("a?"));
// \\d A digit: [0-9], 示意数字, 然而在 java 中对 "\\" 这个符号须要应用 \\ 进行本义, 所以呈现 \\d
p("2345".matches("\\d{2,5}"));
// \\. 用于匹配 "."
p("192.168.0.123".matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"));
// [0-2]指必须是 0~2 中的一个数字
p("192".matches("[0-2][0-9][0-9]"));
}
}
输入后果:全是true
。
范畴[]
[]
用于形容一个字符的范畴,上面是一些例子:
package test;
public class Test04 {private static void p(Object o){System.out.println(o);
}
public static void main(String[] args) {//[abc]指 abc 中的其中一个字母
p("a".matches("[abc]"));
//[^abc]指除了 abc 之外的字符
p("1".matches("[^abc]"));
//a~z 或 A~Z 的字符, 以下三个均是或的写法
p("A".matches("[a-zA-Z]"));
p("A".matches("[a-z|A-Z]"));
p("A".matches("[a-z[A-Z]]"));
//[A-Z&&[REQ]]指 A~Z 中并且属于 REQ 其中之一的字符
p("R".matches("[A-Z&&[REQ]]"));
}
}
输入后果:全是true
。
\s \w \d \S \W \D
对于
\
在 Java 中的字符串中,如果要用到特殊字符,必须通过在后面加 \
进行本义。
举个例子,思考这个字符串 "老师大声说:" 同学们, 快交作业!""
。如果咱们没有转义字符,那么结尾的双引号的完结应该在 说:"
这里,然而咱们的字符串中须要用到双引号,所以须要用转义字符。
应用转义字符后的字符串为"老师大声说:\" 同学们, 快交作业!\""
,这样咱们的原意能力被正确辨认。
同理如果咱们要在字符串中应用\
,也应该在后面加一个\
,所以在字符串中示意为"\\"
。
那么如何在正则表达式中示意要匹配 \
呢?答案为"\\\\"
。
咱们离开思考:因为正则式中示意 \
同样须要本义,所以后面的 \\
示意正则表达式中的转义字符 \
,前面的\\
示意正则表达式中 \
自身,合起来在正则表达式中示意\
。
先来看代码示例:
package test;
public class Test05 {private static void p(Object o){System.out.println(o);
}
public static void main(String[] args) {// \s{4}示意 4 个空白符
p("\n\r\t".matches("\\s{4}"));
// \S 示意非空白符
p("a".matches("\\S"));
// \w{3}示意数字字母和下划线
p("a_8".matches("\\w{3}"));
p("abc888&^%".matches("[a-z]{1,3}\\d+[%^&*]+"));
// 匹配 \
p("\\".matches("\\\\"));
}
}
符号 | 示意 |
---|---|
\d | [0—9] 数字 |
\D | 1 非数字 |
\s | [\t\n\r\f] 空格 |
\S | 2 非空格 |
\w | [0—9A—Z_a—z] 数字字母和下划线 |
\W | 3 非数字字母和下划线 |
边界解决^
^
在中括号内示意取反的意思[^]
,如果不在中括号里则示意字符串的结尾。
代码示例:
package test;
public class Test06 {private static void p(Object o){System.out.println(o);
}
public static void main(String[] args) {
/**
* ^ The beginning of a line 一个字符串的开始
* $ The end of a line 字符串的完结
* \b A word boundary 一个单词的边界, 能够是空格, 换行符等
*/
p("hello sir".matches("^h.*"));
p("hello sir".matches(".*r$"));
p("hello sir".matches("^h[a-z]{1,3}o\\b.*"));
p("hellosir".matches("^h[a-z]{1,3}o\\b.*"));
}
}
输入后果:
true
true
true
false
Matcher 类
matches()
办法会将整个字符串与模板进行匹配。find()
则是从以后地位开始进行匹配,如果传入字符串后首先进行find()
,那么以后地位就是字符串的结尾,对以后地位的具体分析能够看上面的代码示例lookingAt()
办法会从字符串的结尾进行匹配。
代码示例:
package test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test07 {private static void p(Object o){System.out.println(o);
}
public static void main(String[] args) {Pattern pattern = Pattern.compile("\\d{3,5}");
String s = "123-34345-234-00";
Matcher m = pattern.matcher(s);
// 先演示 matches(), 与整个字符串匹配.
p(m.matches());
// 后果为 false, 显然要匹配 3~5 个数字会在 - 处匹配失败
// 而后演示 find(), 先应用 reset()办法把以后地位设置为字符串的结尾
m.reset();
p(m.find());//true 匹配 123 胜利
p(m.find());//true 匹配 34345 胜利
p(m.find());//true 匹配 234 胜利
p(m.find());//false 匹配 00 失败
// 上面咱们演示不在 matches()应用 reset(), 看看以后地位的变动
m.reset();// 先重置
p(m.matches());//false 匹配整个字符串失败, 以后地位来到 -
p(m.find());// true 匹配 34345 胜利
p(m.find());// true 匹配 234 胜利
p(m.find());// false 匹配 00 始边
p(m.find());// false 没有货色匹配, 失败
// 演示 lookingAt(), 从头开始找
p(m.lookingAt());//true 找到 123, 胜利
}
}
如果一次匹配胜利的话
start()
用于返回匹配开始的地位,
end()
用于返回匹配完结字符的前面一个地位。
代码示例:
package test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test08 {private static void p(Object o) {System.out.println(o);
}
public static void main(String[] args) {Pattern pattern = Pattern.compile("\\d{3,5}");
String s = "123-34345-234-00";
Matcher m = pattern.matcher(s);
p(m.find());//true 匹配 123 胜利
p("start:" + m.start() + "- end:" + m.end());
p(m.find());//true 匹配 34345 胜利
p("start:" + m.start() + "- end:" + m.end());
p(m.find());//true 匹配 234 胜利
p("start:" + m.start() + "- end:" + m.end());
p(m.find());//false 匹配 00 失败
try {p("start:" + m.start() + "- end:" + m.end());
} catch (Exception e) {System.out.println("报错了...");
}
p(m.lookingAt());
p("start:" + m.start() + "- end:" + m.end());
}
}
输入后果:
true
start: 0 - end:3
true
start: 4 - end:9
true
start: 10 - end:13
false
报错了...
true
start: 0 - end:3
替换字符串
Matcher
类中的一个办法group()
,它能返回匹配到的字符串。
代码示例:将字符串中的 java
转换为大写
package test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test09 {private static void p(Object o){System.out.println(o);
}
public static void main(String[] args) {Pattern p = Pattern.compile("java");
Matcher m = p.matcher("java I love Java and you");
p(m.replaceAll("JAVA"));//replaceAll()办法会替换所有匹配到的字符串}
}
输入后果:
JAVA I love Java and you
不辨别大小写查找并替换字符串
咱们要在创立模板模板时指定大小写不敏感。
public static void main(String[] args) {Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);// 指定为大小写不敏感的
Matcher m = p.matcher("java I love Java and you");
p(m.replaceAll("JAVA"));
}
输入后果:
JAVA I love JAVA and you
不辨别大小写, 替换查找到的指定字符串
这里演示把查找到第奇数个字符串转换为大写,第偶数个转换为小写。
这里会引入 Matcher
类中一个弱小的办法appendReplacement(StringBuffer sb, String replacement)
,它须要传入一个 StringBuffer 进行字符串拼接。
public static void main(String[] args) {Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("java Java JAVA JAva I love Java and you ?");
StringBuffer sb = new StringBuffer();
int index = 1;
while(m.find()){m.appendReplacement(sb, (index++ & 1) == 0 ? "java" : "JAVA");
index++;
}
m.appendTail(sb);// 把残余的字符串退出
p(sb);
}
输入后果:
JAVA JAVA JAVA JAVA I love JAVA and you ?
分组
先看一个示例:
package test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test10 {private static void p(Object o) {System.out.println(o);
}
public static void main(String[] args) {Pattern p = Pattern.compile("\\d{3,5}[a-z]{2}");
String s = "005aa-856zx-1425kj-29";
Matcher m = p.matcher(s);
while (m.find()) {p(m.group());
}
}
}
输入后果:
005aa
856zx
1425kj
其中正则表达式 "\\d{3,5}[a-z]{2}"
示意 3~5 个数字跟上两个字母,而后打印出每个匹配到的字符串。
如果想要打印每个匹配串中的数字,如何操作呢?
分组机制能够帮忙咱们在正则表达式中进行分组。规定应用 ()
进行分组,这里咱们把字母和数字各分为一组"(\\d{3,5})([a-z]{2})"
而后在调用 m.group(int group)
办法时传入组号即可。
留神
:组号从 0 开始,0 组代表整个正则表达式,从 0 之后,就是在正则表达式中从左到右每一个左括号对应一个组。在这个表达式中第 1 组是数字,第 2 组是字母。
public static void main(String[] args) {Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");// 正则表达式为 3~5 个数字跟上两个字母
String s = "005aa-856zx-1425kj-29";
Matcher m = p.matcher(s);
while(m.find()){p(m.group(1));
}
}
输入后果:
005
856
1425
整顿
- 匹配中文字符的正则表达式:
[\u4e00-\u9fa5]
- 匹配双字节字符(包含汉字在内):
[^\x00-\xff]
- 匹配空行的正则表达式:
\n[\s|]*\r
- 匹配 HTML 标记的正则表达式:
/<(.*)>.*<\/\1>|<(.*) \/>/
- 匹配首尾空格的正则表达式:
(^\s*)|(\s*$)
- 匹配 IP 地址的正则表达式:
/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //
- 匹配 Email 地址的正则表达式:
\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
- 匹配网址 URL 的正则表达式:
http://(/[\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?
- sql 语句:
^(select|drop|delete|create|update|insert).*$
- 非负整数:
^\d+$
- 正整数:
^[0-9]*[1-9][0-9]*$
- 非正整数:
^((-\d+)|(0+))$
- 负整数:
^-[0-9]*[1-9][0-9]*$
- 整数:
^-?\d+$
- 非负浮点数:
^\d+(\.\d+)?$
- 正浮点数:
^((0-9)+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
- 非正浮点数:
^((-\d+\.\d+)?)|(0+(\.0+)?))$
- 负浮点数:
^(-((正浮点数正则式)))$
- 英文字符串:
^[A-Za-z]+$
- 英文大写串:
^[A-Z]+$
- 英文小写串:
^[a-z]+$
- 英文字符数字串:
^[A-Za-z0-9]+$
- 英数字加下划线串:
^\w+$
- E-mail 地址:
^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$
- URL:
^[a-zA-Z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\s*)?$ 或者:^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~@[\]\':+!]*([^<>\"\"])*$
- 邮政编码:
^[1-9]\d{5}$
- 中文:
^[\u0391-\uFFE5]+$
- 电话号码:
^((\(\d{2,3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}(\-\d{1,4})?$
- 手机号码:
^((\(\d{2,3}\))|(\d{3}\-))?13\d{9}$
- 双字节字符(包含汉字在内):
^\x00-\xff
- 匹配首尾空格:
(^\s*)|(\s*$)(像 vbscript 那样的 trim 函数)
- 匹配 HTML 标记:
<(.*)>.*<\/\1>|<(.*) \/>
- 匹配空行:
\n[\s|]*\r
- 提取信息中的网络链接:
(h|H)(r|R)(e|E)(f|F) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?
- 提取信息中的邮件地址:
\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
- 提取信息中的图片链接:
(s|S)(r|R)(c|C) *= *('|")?(\w|\\|\/|\.)+('|"| *|>)?
- 提取信息中的 IP 地址:
(\d+)\.(\d+)\.(\d+)\.(\d+)
- 提取信息中的中国手机号码:
86)*0*13\d{9}
- 提取信息中的中国固定电话号码:
(\(\d{3,4}\)|\d{3,4}-|\s)?\d{8}
- 提取信息中的中国电话号码(包含挪动和固定电话):
(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}
- 提取信息中的中国邮政编码:
[1-9]{1}(\d+){5}
- 提取信息中的浮点数(即小数):
(-?\d*)\.?\d+
- 提取信息中的任何数字:
(-?\d*)(\.\d+)?
- IP 地址:
(\d+)\.(\d+)\.(\d+)\.(\d+)
- 电话区号:
/^0\d{2,3}$/
- 腾讯 QQ 号:
^[1-9]*[1-9][0-9]*$
- 帐号(字母结尾,容许 5 -16 字节,容许字母数字下划线):
^[a-zA-Z][a-zA-Z0-9_]{4,15}$
- 中文、英文、数字及下划线:
^[\u4e00-\u9fa5_a-zA-Z0-9]+$
总结
以上就是对于正则表达式的一个总结和应用阐明,愿正则表达式给你带来更欢快的编程体验。
结尾
我是一个正在被打击还在致力后退的码农。如果文章对你有帮忙,记得 点赞、关注哟
,谢谢!
- 0—9 ↩
- \t\n\r\f ↩
- 0—9A—Z_a—z ↩