JAVA中正则表达式学习总结
一、JAVA中正则表达式相关的类
1. java.util.regex.Pattern
该类用于编译模式，模式可以理解为一个正则表达式，比如：a*b。
用法如下：
// 创建模式
Pattern p = Pattern.compile("a*b");
// 创建该模式的匹配器
Matcher m = p.matcher("aaaaab");
2. java.util.regex.Matcher
该类用于创建匹配器和进行匹配操作。
用法如下：
// 进行匹配操作
boolean b = m.matches();
3. 运行一个正则表达式入门案例
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("a*b");
// 创建该模式的匹配器
Matcher m = p.matcher("aaaaab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
二、正则表达式基础
1. 纯文本也是一个正则表达式
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("ab");
// 创建该模式的匹配器
Matcher m = p.matcher("ab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true;
2. 字符可以匹配任意单个的字符、字母、数字。
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile(".b");
// 创建该模式的匹配器
Matcher m = p.matcher("ab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
3. 用[ ]匹配一组字符
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[0123456789]");
// 创建该模式的匹配器，5和[0123456789]中的某一个匹配
Matcher m = p.matcher("5");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
4. 用-简化[ ]中元素的列举
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[0-9]");
// 创建该模式的匹配器
Matcher m = p.matcher("5");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
类似用法：[a-z]、[A-Z]、[a-zA-Z]、[a-zA-Z0-9]
注意：类似[z-a]的是非法的regex。
-只有在[ ]中才是元字符，如果在[ ]就是一个普通字符。
5. ^取非操作符
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[^0-9a]");
// 创建该模式的匹配器,注意^取非是集合[]中所有元素取非，不只是0-9
Matcher m = p.matcher("a");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：false
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[^0-9]");
// 创建该模式的匹配器
Matcher m = p.matcher("a");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
6. 匹配数字的元字符：\d 等价于[0-9]
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式,注意在正则表达式中\也需要转义即：\\
Pattern p = Pattern.compile("\\d");
// 创建该模式的匹配器
Matcher m = p.matcher("4");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
7. 匹配非数字的元字符：\D相当于[^0-9]
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\D");
// 创建该模式的匹配器
Matcher m = p.matcher("4");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：false
8. \w：匹配任何一个字母数字字符（大小写均可）或下划线字符（等价于[a-zA-Z0-9_]）
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\w");
// 创建该模式的匹配器
Matcher m = p.matcher("_");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
9. 匹配任何一个非字母数字或非下划线字符（等价于[^a-zA-Z0-9_]）
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\W");
// 创建该模式的匹配器
Matcher m = p.matcher("_");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
10. +匹配一个或多个（至少一个）。+遇到[ ]一般放在[ ]后，如果放在[ ]中就只是一个元素
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 +可以重复一个集合[]也可以是一个字符
Pattern p = Pattern.compile("[abc]+");
// 创建该模式的匹配器
Matcher m = p.matcher("aaccbbabc");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d+");
// 创建该模式的匹配器
Matcher m = p.matcher("1114578");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
11. *匹配零个或多个
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d*");
// 创建该模式的匹配器
Matcher m = p.matcher("");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
12. ？匹配零个或一个（最多一个）
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d?");
// 创建该模式的匹配器
Matcher m = p.matcher("");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d?");
// 创建该模式的匹配器
Matcher m = p.matcher("2");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d?");
// 创建该模式的匹配器
Matcher m = p.matcher("25");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：false
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[abc]?");
// 创建该模式的匹配器
Matcher m = p.matcher("c");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
13. { }指定重复匹配的次数
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 {2}表示匹配两次
Pattern p = Pattern.compile("[abc]{2}");
// 创建该模式的匹配器
Matcher m = p.matcher("cc");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 {2,5}最少匹配2次，最多匹配5次
Pattern p = Pattern.compile("[abc]{2,5}");
// 创建该模式的匹配器
Matcher m = p.matcher("ccab");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 最好重复匹配3次
Pattern p = Pattern.compile("[abc]{3,}");
// 创建该模式的匹配器
Matcher m = p.matcher("ccabbbbbbbbbbbbbb");
// 进行匹配操作
boolean b = m.matches();
System.out.println(b);
}
}
运行结果：true
14. ( )中的|表示“或”
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("t(a|e|i|o|oo)n");
// 输出匹配结果
System.out.println(p.matcher("tan").matches());
System.out.println(p.matcher("ten").matches());
System.out.println(p.matcher("tin").matches());
System.out.println(p.matcher("ton").matches());
//[ ]中只能匹配一个字符，而( )中可以不止一个字符，如“oo”
System.out.println(p.matcher("toon").matches());
}
}
运行结果：
true
true
true
true
true
当一个模式使用多次时,以下写法会编译多次,会影响性能.
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
//如果要多次使用一种模式，编译一次后重用此模式比每次都调用此方法效率更高。
System.out.println(Pattern.matches("t(a|e|i|o|oo)n", "toon"));
}
}
运行结果：true
15. \b指定单词边界,匹配的长度可以认为为“0”。b是英文boundary(边界)的首字母。
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\bis\\b");
// 创建该模式的匹配器
Matcher m = p.matcher("This is a dog,that is a cat");
// 进行匹配操作
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
is
is
有4种位置被认为是“单词边界”：
1)在字符串的第一个字符前的位置(如果字符串的第一个字符是一个“单词字符”)
2)在字符串的最后一个字符后的位置(如果字符串的最后一个字符是一个“单词字符”)
3)在一个“单词字符”和“非单词字符”之间，其中“非单词字符”紧跟在“单词字符”之后
4)在一个“非单词字符”和“单词字符”之间，其中“单词字符”紧跟在“非单词字符”后面“单词字符”是可以用“\w”匹配的字符，“非单词字符”是可以用“\W”匹配的字符。
正则表达式匹配单词的原理探讨：
让我们看看把正则表达式<<\bis\b>>应用到字符串“This island is beautiful”。引擎先处理符号<<\b>>。因为\b是0长度 ，所以第一个字符T前面的位置会被考察。
因为T是一个“单词字符”，而它前面的字符是一个空字符(void)，所以\b匹配了单词边界。接着<<i>>和第一个字符“T”匹配失败。
匹配过程继续进行，直到第五个空格符，和第四个字符“s”之间又匹配了<<\b>>。然而空格符和<<i>>不匹配。
继续向后，到了第六个字符“i”，和第五个空格字符之间匹配了<<\b>>，然后<<is>>和第六、第七个字符都匹配了。
然而第八个字符和第二个“单词边界”不匹配，所以匹配又失败了。到了第13个字符i，因为和前面一个空格符形成“单词边界”，同时<<is>>和“is”匹配。
引擎接着尝试匹配第二个<<\b>>。因为第15个空格符和“s”形成单词边界，所以匹配成功。引擎“急着”返回成功匹配的结果。
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 ,匹配以th或Th开头的单词（注意：模式默认是区分大小写的）
Pattern p = Pattern.compile("(\\bth\\w+|\\bTh\\w+)");
// 创建该模式的匹配器
Matcher m = p.matcher("This is a dog,that is a cat");
// 进行匹配操作
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
This
that
16. 字符串边界
用来定义字符串边界的元字符有两个：一个是用来定义字符串开头的^,另一个是用来定义字符串结尾的$。
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式 匹配一个字符串
Pattern p = Pattern.compile("^this\\s+a\\s+dog$");
// 创建该模式的匹配器
Matcher m = p.matcher("this a dog");
// 进行匹配操作，并输出匹配结果
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
this a dog
17. 注意：重复匹配的元字符（*，？，｛3｝，+）只作用于紧挨着她的的前一个字符或元字符或字表达式。
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("https?");
// 创建该模式的匹配器
Matcher m = p.matcher("http");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
http
18. ()子表达式。子表达式用()包裹起来，可以理解为包含其他元字符的一个元字符。
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}");
// 创建该模式的匹配器
Matcher m = p.matcher("Pinging baidu.com [12.159.46.200] with 32 bytes of data");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
12.159.46.200
ublic class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式，匹配ip。把上面重复的\\d{1,3}\\.可以认为是一个字表达式
Pattern p = Pattern.compile("(\\d{1,3}\\.){3}\\d{1,3}");
// 创建该模式的匹配器
Matcher m = p.matcher("Pinging baidu.com [12.159.46.200] with 32 bytes of data;");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
12.159.46.200
19. 子表达式的嵌套
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式,匹配19或20开头的年份
Pattern p = Pattern.compile("(19|20)\\d{2}");
// 创建该模式的匹配器
Matcher m = p.matcher("today is 2014-4-7");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
2014
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式,匹配一个合法IP(最大只能是255)
Pattern p = Pattern.compile("((\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])\\.){3}((\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))");
// 创建该模式的匹配器
Matcher m = p.matcher("IP: 265.255.10.0");
System.out.println(m.matches());
}
}
运行结果：
false
三、常用实例
1. 只匹配中文
public class C {
public static void main(String[] args) {
new C().test();
}
public void test(){
// 创建模式
Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
// 创建该模式的匹配器
Matcher m = p.matcher("china中国");
//输出匹配的字符串
while(m.find()){
System.out.println(m.group());
}
}
}
运行结果：
中
国
JAVA中正则表达式学习总结的更多相关文章
- java中正则表达式基本用法
正则表达式是一种可以用于模式匹配和替换的规范,一个正则表达式就是由普通的字符(例如字符a到z)以及特殊字符(元字符)组成的文字模式,它 用以描述在查找文字主体时待匹配的一个或多个字符串.正则表达式作为 ...
- java基础---->java中正则表达式二
跟正则表达式相关的类有:Pattern.Matcher和String.今天我们就开始Java中正则表达式的学习. Pattern和Matcher的理解 一.正则表达式的使用方法 一般推荐使用的方式如下 ...
- Java中正则表达式去除html标签
Java中正则表达式去除html的标签,主要目的更精确的显示内容,比如前一段时间在做类似于博客中发布文章功能,当编辑器中输入内容后会将样式标签也传入后台并且保存数据库,但是在显示摘要的时候,比如显示正 ...
- java中正则表达式基本用法（转）
https://www.cnblogs.com/xhj123/p/6032683.html 正则表达式是一种可以用于模式匹配和替换的规范,一个正则表达式就是由普通的字符(例如字符a到z)以及特殊字符( ...
- JAVA中正则表达式常用的四个方法
JAVA中正则表达式处理字符串的四个常用方法:匹配.分割.替换.截取.其跟字符串的常用函数相似,但是使用正则表达式会更简单.更加简洁.下面是具体的例子: public class TestRegex ...
- PHP中正则表达式学习及应用（四）
正则表达式在PHP中的应用 1.匹配功能 2.替换功能 3.分割功能 例如: <?php $str="addsds{title}hfksjd{author}hfjdkjd{conn}j ...
- PHP中正则表达式学习及应用（三）
正则表达式中的“模式修正符” 1.运算顺序 2.模式修正符 i 正则内容在匹配时候不区分大小写(默认是区分的) 例如: <?php $mode="/[a-z]/i"; ...
- PHP中正则表达式学习及应用（二）
正则表达式中的“元字符” * 匹配前一个内容的0次1次或多次 例如: <?php $mode="/go*gle/"; //前一个内容指的是 * 的前一个字符 o ,在$str ...
- PHP中正则表达式学习及应用(一)
1.正则表达式的介绍和作用 什么是正则表达式 在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串 的需要.正则表达式就是用于描述这些规则的语法. 例:在判断用户邮件地址格式.手机号码 ...
随机推荐
- 跟着Nisy一起学习C语言
编辑器是使用环境turboc的IDE,使用dos窗口中的edit作为编辑器,有点类似于vim:使用的是xp-sp3的虚拟机上的系统. Nisy说要有两种语言,脚本语言以及一个底层语言,比如现在我的py ...
- Fask中的路由－模版－静态文件引用 及宏定义与表单
文档: flask: http://docs.jinkan.org/docs/flask/quickstart.html#redirects-and-errors jinja2 http://docs ...
- Hadoop学习笔记(9) ——源码初窥
Hadoop学习笔记(9) ——源码初窥 之前我们把Hadoop算是入了门,下载的源码,写了HelloWorld,简要分析了其编程要点,然后也编了个较复杂的示例.接下来其实就有两条路可走了,一条是继续 ...
- 十二、curator recipes之双重屏障DoubleBarrier
简介 curator实现了单个屏障barrier和双重屏障DoubleBarrier,单个屏障就是在一个进程里面设置了屏障,并等待其它进程去移除这个屏障,否则一直阻塞.双重屏障就是设置了两道屏障,两个 ...
- nginx 安装配置和常用命令
基本环境:CentOS 1. 下载 nginx [root@localhost ~]# cd Downloads/ [root@localhost Downloads]# wget http://ng ...
- Code Signal_练习题_palindromeRearranging
Given a string, find out if its characters can be rearranged to form a palindrome. Example For input ...
- UOJ#400. 【CTSC2018】暴力写挂
传送门 看到要求两棵树的 \(lca\) 深度不太好操作 考虑枚举第二棵树的 \(lca\),这样剩下的都是只和第一棵树有关的 而注意到 \(dis(x,y)=d(x)+d(y)-2d(lca(x,y ...
- Css选择器(上) 让样式无孔不入
css选择器 一个可以选择样式的工具, 这里适用于无论是内部代码还是外部引用 abc.css 这类型的文件. 基本选择器*{ } 就是一个简单的*, 代表应用于全部. 不适合于个性 ...
- Spring Data MongoDB 模糊查询
Pattern pattern = Pattern.compile("^.*" + value + ".*$"); Query query = new Quer ...
- OkHttp3源码详解(三) 拦截器
1.构造Demo 首先构造一个简单的异步网络访问Demo: OkHttpClient client = new OkHttpClient(); Request request = new Reques ...