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.正则表达式的介绍和作用 什么是正则表达式 在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串 的需要.正则表达式就是用于描述这些规则的语法. 例:在判断用户邮件地址格式.手机号码 ...
随机推荐
- yii 页面加载完成后弹出模态框
<?php $js = <<<JS $('#page-modal').modal('show');//页面加载完显示模态框 $('.modal-dialog').css('wi ...
- Cheatsheet: 2018 11.01 ~ 2019 02.28
Golang FromXToGo micro - A microservice toolkit Other Easy parsing of Excel spreadsheet format with ...
- Java学习--Calendar 类的应用
Calendar 类的应用 Date 类最主要的作用就是获得当前时间,同时这个类里面也具有设置时间以及一些其他的功能,但是由于本身设计的问题,这些方法却遭到众多批评,不建议使用,更推荐使用 Calen ...
- MySQL建表语句的一些特殊字段
这里的字段会不断更新 unsigned 这个字段一般在建表的时候写在Id上,用来表示不分正负号 tinyint 这个字段如果设置为UNSIGNED类型,只能存储从0到255的整数,不能用来储存负数. ...
- 撩课-Java每天5道面试题第16天
111.什么是乐观锁(Optimistic Locking)? 悲观锁,正如其名, 它指的是对数据被外界 包括本系统当前的其他事务, 以及来自外部系统的事务处理 修改持保守态度, 因此,在整个数据处理 ...
- Mybatis之简单注解
Mybatis使用注解实现主键自增长: oracle: @SelectKey(statement="select my_seq.nextval from dual",resultT ...
- BZOJ1021 [SHOI2008]循环的债务
Description Alice.Bob和Cynthia总是为他们之间混乱的债务而烦恼,终于有一天,他们决定坐下来一起解决这个问题. 不过,鉴别钞票的真伪是一件很麻烦的事情,于是他们决定要在清还债务 ...
- 【数据库】10.0 MySQL常用语句（一）
显示数据库语句: SHOW DATABASES 只是显示数据库的名字 显示数据库创建语句: SHOW CREATE DATABASE db_name 数据库删除语句: DROP DATABASE ...
- Css选择器(上) 让样式无孔不入
css选择器 一个可以选择样式的工具, 这里适用于无论是内部代码还是外部引用 abc.css 这类型的文件. 基本选择器*{ } 就是一个简单的*, 代表应用于全部. 不适合于个性 ...
- JavaScript - 收藏集 - 掘金
Angular 中的响应式编程 -- 浅淡 Rx 的流式思维 - 掘金第一节:初识Angular-CLI第二节:登录组件的构建第三节:建立一个待办事项应用第四节:进化!模块化你的应用第五节:多用户版本 ...