尚学堂-马士兵-专题-正则表达式
时间:2022-07-25
本文章向大家介绍尚学堂-马士兵-专题-正则表达式，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。
一、最简单的正则表达式
- String类的一个方法matches。
package com.string;
public class RegexTest {
public static void main(String[] args) {
/*
* 最简单的正则表达式
* 这里使用的是String类的matches方法.
* 这个方法是比较字符是否匹配
* .表示的时任意一个字符
*/
System.out.println("abc".matches("..."));
}
}正则表达式是处理字符串的。 其实更确切的说，正则表达式是处理字符的。 就拿上面的例子来说， 每一个点代表一个字符。 那么abc是不是三个字符呀？是， 所以满足条件。
replaceAll : String一个非常好用的方法
package com.string;
public class RegexTest {
public static void main(String[] args) {
/*
* 最简单的正则表达式
* 这里使用的是String类的matches方法.
* 这个方法是比较字符是否匹配
* .表示的时任意一个字符
*/
System.out.println("abc".matches("..."));
/**
* String的另一个很有用的方法: replaceAll,这个方法有两个参数
* 第一个参数: regex正则表达式
* 第二个参数: 替换的字符串
* 下面这个语句的含义: 替换所有的数组为-
*/
System.out.println("a43215b".replaceAll("\d", "-"));
}
}运行结果true
a-----bString的另一个很有用的方法: replaceAll,这个方法有两个参数。
replaceAll(String regex, String replacement) ： 字符串匹配正则表达式， 匹配成功的替换为第二个参数自定的字符串- 简单认识pattern和Marcher 上面3句话可以使用下面一句话代替. 但为什么还要用三句话来写呢? * 1. 通过Parrern.compile编译以后, 速度回大幅度提高 * 2. 可以很使用Pattern和Matcher的一些方法
package com.string;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexTest {
public static void main(String[] args) {
/**
* 简单认识Pattern 和 Matcher
*/
//compile:方法, 指的是将一个正则表达式先编译, 这样做的好处是效率提高了.
//[a-z]:表示的事,a-z任意一个字符
//{3} 表示的是3个
Pattern p = Pattern.compile("[a-z]{3}");
//matcher方法是创建一个输入与匹配模式的匹配器.
Matcher m = p.matcher("abx");
//尝试将整个区域与模式进行匹配
System.out.println(m.matches());
/*
* 上面3句话可以使用下面一句话代替. 但为什么还要用三句话来写呢?
* 1. 通过Parrern.compile编译以后, 速度回大幅度提高
* 2. 可以很使用Pattern和Matcher的一些方法
*/
System.out.println("abc".matches("[a-z]{3}"));
}
}二、认识正则表达式
-
初识 . * + ? {n} {n,} {n,m}
- . 代表任意字符
- * 代表0或者多个
- + 代表1个或者多个
- ? 代表0或者1个
- {n} :代表某一个字符出现指定的次数
- {n,}: 至少出现某个字符n次
- {n, m}: 至少n次, 至多m次 运行结果
true true true true true true false true true true false true
package com.string;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexTest2 {
public static void main(String[] args) {
/**
* 初识 . * + ?
* . 代表任意字符
* * 代表0或者多个
* + 代表1个或者多个
* ? 代表0或者1个
* {n} :代表某一个字符出现指定的次数
* {n,}: 至少出现某个字符n次
* {n, m}: 至少n次, 至多m次
*/
System.out.println("aaa".matches("..."));
System.out.println("a".matches("."));
System.out.println("aa".matches("aa"));
System.out.println("aaa".matches("a*"));
System.out.println("aaa".matches("a+"));
System.out.println("".matches("a*"));
System.out.println("aaa".matches("a?"));
System.out.println("".matches("a?"));
System.out.println("a".matches("a?"));
System.out.println("23568745896512".matches("\d{3,100}"));
/*
* \d表示任意有效字符.
* . 表示的是常用的.,但是.在正则表达式中有特殊含义(任意字符), 所以需要转义为.
* 而在正则表达式中也是特殊字符, 所以还需要再加一个. 因此就是\.
*
* 下面这个例子是一个简单的ip地址的匹配. 但是如果超出了256怎么办呢?可以再用更详细的方法限定
*/
System.out.println("192.168.203.aaa".matches("\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"));
//这是一种简单的方法
System.out.println("192".matches("[0-2][0-9][0-9]"));
}
}- 范围 [] 中括号表示范围, 这个范围限定的时一个字符. 上面的案例显示了并集的表示方法, 交集的表示方法.
/**
* 范围
* 1. 中括号表示范围
* 2. 每个范围只对应一个字符, 无论这个范围有多长
* 3.
*/
System.out.println("=========================================");
//中括号表示范围,abc表示确定范围
System.out.println("a".matches("[abc]"));
//a-z表示一个指定的范围
System.out.println("a".matches("[a-z]"));
//表示的时或, a-z或者A-Z,满足一个条件即可
System.out.println("a".matches("[a-zA-Z]"));
//或者的另一种表示方法,使用分隔符|
System.out.println("a".matches("[a-z]|[A-Z]"));
//或的另一种表示方法
System.out.println("a".matches("[a-z[A-Z]]"));
//交集的表示方法
System.out.println("R".matches("[A-Z&&[Q-Z]]"));-
认识 s w d
- s 表示的时空白字符,包括[ ntfrx0B]
- S表示的时非空白字符,即[^s]
- w: 表示的是字母字符, 包括[a-zA-Z_0-9]
- W: 表示的是非字母字符, 即[^w]
- d: 表示的是数字,范围[0-9]
- D: 表示的时非数字, 即[^0-9] 或者 [^d]
- 在正则表达式中使用四个表示. 即\\. 下面的例子说了为什么这样表示. java中的使用的是两个, 即\
/**
* 认识 s w d
* s: 代表空白字符 ：[ tnx0Bfr]
* S: 代表非空白字符, 除了空白字符以外的字符 [^s]
* w: 单词字符 [a-zA-Z_0-9]
* W: 非单词字符 [^w]
*
* d: 表示的时数字[0-9]
* D: 表示的时非数字[^d]或者[^0-9]
*/
System.out.println("============================");
/*
* s表示的时空白字符[ ntx08fr]. 在正则表达式中, s本身代表的是空白字符. 由于有特殊的含义,
* 所以, 在写s的时候, 需要写成\s.
* 下面这句话是匹配4个空白字符 - true
*/
System.out.println(" ntr".matches("\s{4}"));
//S表示的时非空白字符, 空格是空白字符, 所以返回false
System.out.println(" ".matches("\S"));
//\w匹配的是单词字符, 单词字符的范围是[a-zA-Z_0-9], 所以返回的时-true
System.out.println("a_8".matches("\w{1,3}"));
/*
* 下面这句话的含义
* [a-z]{0,3}表示0-3个字符
* \d+:表示的是1个或多个数字
* [&^%$]+: 表示的时中括号中的一个或者多个
*/
System.out.println("abc888&^%".matches("[a-z]{0,3}\d+[&^%#]+"));
/*
* 下面说说本身
* 正则表达式如何表示斜杠呢. 比如我有一个反斜杠, 如何匹配?
*
* 首先在java中, 是有特殊含义的. 比如"表示的是一个". 如果想表示字符串类型的, 不能直接使用"",因为后一个双引号会被转义.
* 因此在java中,想要表示,需要使用\
*
* 在正则表达式中, 有特殊的含义, 比如s d w. 因此表示需要使用\. 然后\表示的是一个, 和后面的"会发生转义.
* 我们采取的方式是对这两个反斜杠都进行转义, 所以就是\\.
*
*/
System.out.println("\".matches("\\"));
-
正则表达式的边界处理
- ^ : 行的开头
- $行的几位
- b单词边界
- B非单词边界 练习: 单词边界
/**
* 边界字符
* ^: 行的开头
* $: 行的结尾
* b: 单词边界
* B: 非单词边界
*/
System.out.println("===============================");
/*
* ^表示的是行的开头. 写在一行的最前面
* 表示以a开头,后面跟着1个或者多个字符
*/
System.out.println("abc".matches("^a.*"));
/*
* $表示行的结尾. 如果$出现在最后, 则表示这一行已经结尾了.
* 下面的正则表达式表示, 以任意字符结尾
*/
System.out.println("def".matches(".*$"));
//以h开头
System.out.println("hello sir".matches("^h.*"));
//以ir结尾
System.out.println("hello sir".matches(".*ir$"));
/*
* 下面这个语句的含义
* ^h: 以h开头
* \w{0,3}: h后面跟着0-3个单词字符
* o: 后面跟着一个o
* b: 表示的是单词的结尾.
* .*: 表示1个或多个字符
* ir$: 以ir结尾
*/
System.out.println("hello sir".matches("^h\w{0,3}o\b.*ir$"));
/*
* 下面这个案例返回false, 和上面的区别是, 单词hello, o不是单词的结尾
*/
System.out.println("hellosir".matches("^h\w{0,3}o\b.*ir$"));
/*
* 如何匹配带有空格的空白行. 空白行虽然没有字符, 但是这一行可能有空白字符, 如空格等.
* java中,换行用n表示
*
*/
System.out.println(" n".matches("^[\s&&[^\n]]*\n$"));/**
* 边界字符
* ^: 行的开头
* $: 行的结尾
* b: 单词边界
* B: 非单词边界
*/
System.out.println("===============================");
/*
* ^表示的是行的开头. 写在一行的最前面
* 表示以a开头,后面跟着1个或者多个字符
*/
System.out.println("abc".matches("^a.*"));
/*
* $表示行的结尾. 如果$出现在最后, 则表示这一行已经结尾了.
* 下面的正则表达式表示, 以任意字符结尾
*/
System.out.println("def".matches(".*$"));
//以h开头
System.out.println("hello sir".matches("^h.*"));
//以ir结尾
System.out.println("hello sir".matches(".*ir$"));
/*
* 下面这个语句的含义
* ^h: 以h开头
* \w{0,3}: h后面跟着0-3个单词字符
* o: 后面跟着一个o
* b: 表示的是单词的结尾.
* .*: 表示1个或多个字符
* ir$: 以ir结尾
*/
System.out.println("hello sir".matches("^h\w{0,3}o\b.*ir$"));
/*
* 下面这个案例返回false, 和上面的区别是, 单词hello, o不是单词的结尾
*/
System.out.println("hellosir".matches("^h\w{0,3}o\b.*ir$"));
/*
* 如何匹配带有空格的空白行. 空白行虽然没有字符, 但是这一行可能有空白字符, 如空格等.
* java中,换行用n表示
*
*/
System.out.println(" n".matches("^[\s&&[^\n]]*\n$"));
三、Pattern和Matcher
- mathes的用法：匹配整个字符串, 也就是判断是否整个字符串是否完全匹配正则表达式. 结果： false 分析：正则表达式是3-5个数组， 而str字符串第四个字符就不是数字， 所以返回false
public static void main(String[] args) {
/**
* 使用Matcher和Pattern匹配字符串
*/
Pattern p = Pattern.compile("\d{3,5}");
String str = "123-45678-456-78";
//将str和正则表达式p进行匹配
Matcher m = p.matcher(str);
//matches:匹配整个字符串--首先位数就不匹配, 所以返回false
System.out.println(m.matches());
}- find（）的用法：查找正则表达式，只要有符合条件的， 就返回true 结果: true true true false 分析: find是查找符合条件的字符串, 找到以后就把这个字符串吃了. 当在使用find查找的时候, 会在剩下的字符串中进行匹配, 所以, 前三个返回的是true,第四个返回的是false. fa
public static void main(String[] args) {
/**
* 使用Matcher和Pattern匹配字符串
*/
Pattern p = Pattern.compile("\d{3,5}");
String str = "123-45678-456-78";
//将str和正则表达式p进行匹配
Matcher m = p.matcher(str);
//find: 从整个字符串中查找, 返回的是,剩下的字符串
System.out.println(m.find());
System.out.println(m.find());
System.out.println(m.find());
System.out.println(m.find());
}- matches和find会相互影响 运行结果: false true true false false 分析: 这次为什么后两个find都是返回的false呢?因为第一个matches匹配到第四个字符的时候,正则表达式判断, 匹配失败. 那么下面再find查找的时候, 是从第五个字符开始的
package com.string;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexTest3 {
public static void main(String[] args) {
/**
* 使用Matcher和Pattern匹配字符串
*/
Pattern p = Pattern.compile("\d{3,5}");
String str = "123-45678-456-78";
//将str和正则表达式p进行匹配
Matcher m = p.matcher(str);
//matches:匹配整个字符串--首先位数就不匹配, 所以返回false
System.out.println(m.matches());
//find: 从整个字符串中查找, 返回的是,剩下的字符串
System.out.println(m.find());
System.out.println(m.find());
System.out.println(m.find());
System.out.println(m.find());
}
}- lookingAt:每次都是从头开始查找, 看是否有符合条件的. 运行结果: true true true true 分析: 每次都从头开始找, 所以,每次都能匹配成功
public static void main(String[] args) {
/**
* 使用Matcher和Pattern匹配字符串
*/
Pattern p = Pattern.compile("\d{3,5}");
String str = "123-45678-456-78";
//将str和正则表达式p进行匹配
Matcher m = p.matcher(str);
//lookingAt():从头开始查找
System.out.println(m.lookingAt());
System.out.println(m.lookingAt());
System.out.println(m.lookingAt());
System.out.println(m.lookingAt());
}- reset()：重置。将光标移动到字符串的最开始。 我们在第3个例子中看到了。 matches方法的执行，影响到了find的运行。 加入我的find就要从字符串开始查找，怎么办呢， 使用reset（） 运行结果： false true true true false 分析： 这样就可以看出， matches方法的运行，并没有影响到find。find查找到第四次的时候，查找失败了。
public static void main(String[] args) {
/**
* 使用Matcher和Pattern匹配字符串
*/
Pattern p = Pattern.compile("\d{3,5}");
String str = "123-45678-456-78";
//将str和正则表达式p进行匹配
Matcher m = p.matcher(str);
//matches:匹配整个字符串--首先位数就不匹配, 所以返回false
System.out.println(m.matches());
m.reset();
//find: 从整个字符串中查找, 返回的是,剩下的字符串
System.out.println(m.find());
System.out.println(m.find());
System.out.println(m.find());
System.out.println(m.find());
}-
start()和end()方法:
- 上面使用find()方法找到了字符串, 那么怎么知道找到的字符串的位置呢? 使用start()和end()就可查看位置了
- start()和end()方法必须使用在能够find到字符的位置, 如果find返回false, 使用start和end会异常
- start()和end():都是从0 开始计数. 返回的区间包括start,不包括end
public static void main(String[] args) {
/**
* 使用Matcher和Pattern匹配字符串
*/
Pattern p = Pattern.compile("\d{3,5}");
String str = "123-45678-456-78";
//将str和正则表达式p进行匹配
Matcher m = p.matcher(str);
//matches:匹配整个字符串--首先位数就不匹配, 所以返回false
System.out.println(m.matches());
m.reset();
//find: 从整个字符串中查找, 返回的是,剩下的字符串
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());
System.out.println(m.find());
}public static void main(String[] args) {
/**
* 使用Matcher和Pattern匹配字符串
*/
Pattern p = Pattern.compile("\d{3,5}");
String str = "123-45678-456-78";
//将str和正则表达式p进行匹配
Matcher m = p.matcher(str);
//matches:匹配整个字符串--首先位数就不匹配, 所以返回false
System.out.println(m.matches());
m.reset();
//find: 从整个字符串中查找, 返回的是,剩下的字符串
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());
System.out.println(m.find());
System.out.println(m.start() + "-" + m.end());
System.out.println(m.find());
}-
replaceAll方法和appendReplacement()方法的使用
- 案例一: 找到符合正则表达式的字符串,并打印输出. 很显然这里只能找到一个符合添加的. 那就是java. 其他大小写不符合.
- 案例二： 不区分大小写， 替换所有的java为大写。 这里使用到了Pattern的另一个构造方法compile(regex, flag). flag有一些固定的值. 可以参考api
/**
* replaceAll
*/
Pattern pp = Pattern.compile("java");
String ss = "java Java JaVa JAva IloveJava you hateJaVA ";
Matcher mm = pp.matcher(ss);
/*
* 需求一: 找到所有符合条件字符串
* 很显然, 只有一个符合条件, 找到并打印出来
*/
if(mm.find()){
//mm.group()打印输出这个组的内容
System.out.println(mm.group());
} CASE_INSENSITIVE:大小写不敏感, 即不区分大小写. 我们这里使用的就是这个
/*
* 需求二: 不区分大小写,查找所有符合条件的字符串, 将其替换为大写
*/
//第二个参数代表,大小写不敏感
Pattern pp2 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
String ss2 = "java Java JaVa JAva IloveJava you hateJaVA ";
Matcher mm2 = pp2.matcher(ss);
//查找替换直接使用replaceAll即可
//下面这句话的含义: 查找所有符合条件的表达式,并将其替换为JAVA
System.out.println(mm2.replaceAll("JAVA"));replaceAll: 查找并替换.
-
- 案例三: 不区分大小写, 查找所有的字符串, 将奇数个替换为java, 偶数个替换为JAVA
//第二个参数代表,大小写不敏感
Pattern pp2 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
String ss2 = "java Java JaVa JAva IloveJava you hateJaVA faddafdfa";
Matcher mm2 = pp2.matcher(ss);
/*
* 需求三: 不区分大小写, 查找所有符合条件的字符串. 将其奇数个替换为java, 偶数个替换为JAVA
*
* 方法有很多, 我们介绍一个Matcher的新方法appendReplacement()
*/
int num = 0;
StringBuffer buf = new StringBuffer();
while(mm2.find()){
num ++;
if(num % 2 == 0){
mm2.appendReplacement(buf, "JAVA");
} else {
mm2.appendReplacement(buf, "java");
}
}
//最后打印buffer, 因为最后的结果都填到buffer里面了
System.out.println(buf);java JAVA java JAVA Ilovejava you hateJAVA//第二个参数代表,大小写不敏感
Pattern pp2 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
String ss2 = "java Java JaVa JAva IloveJava you hateJaVA fabdafdfa";
Matcher mm2 = pp2.matcher(ss);
/*
* 需求三: 不区分大小写, 查找所有符合条件的字符串. 将其奇数个替换为java, 偶数个替换为JAVA
*
* 方法有很多, 我们介绍一个Matcher的新方法appendReplacement()
*
*/
int num = 0;
StringBuffer buf = new StringBuffer();
while(mm2.find()){
num ++;
if(num % 2 == 0){
mm2.appendReplacement(buf, "JAVA");
System.out.println(buf);
} else {
mm2.appendReplacement(buf, "java");
System.out.println(buf);
}
}
//最后打印buffer, 因为最后的结果都填到buffer里面了
System.out.println(buf);java
java JAVA
java JAVA java
java JAVA java JAVA
java JAVA java JAVA Ilovejava
java JAVA java JAVA Ilovejava you hateJAVA
java JAVA java JAVA Ilovejava you hateJAVA//第二个参数代表,大小写不敏感
Pattern pp2 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
String ss2 = "java Java JaVa JAva IloveJava you hateJaVA faddafdfa";
Matcher mm2 = pp2.matcher(ss);
//查找替换直接使用replaceAll即可
//下面这句话的含义: 查找所有符合条件的表达式,并将其替换为JAVA
System.out.println(mm2.replaceAll("JAVA"));
mm2.reset();
/*
* 需求三: 不区分大小写, 查找所有符合条件的字符串. 将其奇数个替换为java, 偶数个替换为JAVA
*
* 方法有很多, 我们介绍一个Matcher的新方法appendReplacement()
*
*/
int num = 0;
StringBuffer buf = new StringBuffer();
while(mm2.find()){
num ++;
if(num % 2 == 0){
mm2.appendReplacement(buf, "JAVA");
System.out.println(buf);
} else {
mm2.appendReplacement(buf, "java");
System.out.println(buf);
}
}
mm2.appendTail(buf);
//最后打印buffer, 因为最后的结果都填到buffer里面了
System.out.println(buf);java JAVA java JAVA Ilovejava you hateJAVA faddafdfa//第二个参数代表,大小写不敏感
Pattern pp2 = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
String ss2 = "java Java JaVa JAva IloveJava you hateJaVA faddafdfa";
Matcher mm2 = pp2.matcher(ss);
/*
* 需求三: 不区分大小写, 查找所有符合条件的字符串. 将其奇数个替换为java, 偶数个替换为JAVA
*
* 方法有很多, 我们介绍一个Matcher的新方法appendReplacement()
*/
int num = 0;
StringBuffer buf = new StringBuffer();
while(mm2.find()){
num ++;
if(num % 2 == 0){
mm2.appendReplacement(buf, "JAVA");
} else {
mm2.appendReplacement(buf, "java");
}
}
//最后打印buffer, 因为最后的结果都填到buffer里面了
System.out.println(buf);8. 分组group()分组. 下面来看案例
-
- 案例一: 一个简单的小例子: 使用分组打印匹配成功的字符串 输出结果: 我们看到, 如预期的, 有三组满足条件. 那么, 如果我想要得到三组中每一组的数字,怎么办呢?看案例二
45896aa 758dd 632ee-
案例二: 得到分组后,每一组的字符串. 这里有几个知识点
- 使用()对正则表达式进行分组
- 到底是第几组?从左括号开始计算, 第几个括号就是第几组
- 分好的组可以通过group(组号) 获得相应的内容
- 获取不存在的组将报异常
- fda
- fa 运行结果:
获取整个组的内容 45896aa 758dd 632ee 获取第一组---全部是数字的组 45896 758 632 获取第二组---全部是字母的组 aa dd ee
/* * 案例二: 获得上一个案例中每一组的数字. * * 这里才真正涉及到了分组的概念 * 我们可以在正则表达式通过()来进行分组, 例如\d{3,5}[a-z]{2}表示的时3-5个数字, 2个字符. 我们将数字分为一组, 字母分为一组. * 正则表达式的写法如下(\d{3,5})([a-z]{2}). 这样呢就分好组了, 其实, 在这里一共是有三组, 整个字符串也算作一组. * * 分号组以后, 我们通过组号来获取每一组的内容. 如何知道我要获取的时哪一组呢? 看左括号, 第几个左括号,就是第几组. * 获取不存在的组将报异常 */ Pattern pp4 = Pattern.compile("(\d{3,5})([a-z]{2})"); String str4 = "45896aa-758dd-632ee-00a"; Matcher mm4 = pp4.matcher(str4); System.out.println("获取整个组的内容"); while(mm4.find()){ System.out.println(mm4.group()); } System.out.println("获取第一组---全部是数字的组"); mm4.reset(); while(mm4.find()){ System.out.println(mm4.group(1)); } System.out.println("获取第二组---全部是字母的组"); mm4.reset(); while(mm4.find()){ System.out.println(mm4.group(2)); }
/**
* 分组
*/
/*
* 案例一: 我们来看一个分组的简单例子
*/
//这个正则表达式的含义是. 数字3-5个后跟两个字母
Pattern pp3 = Pattern.compile("\d{3,5}[a-z]{2}");
String str3 = "45896aa-758dd-632ee-00a";
Matcher mm3 = pp3.matcher(str3);
/*
* 分析: 这里面有几个符合条件呢?
* 目测3个
*/
while(mm3.find()){
System.out.println(mm3.group());
}9. Qualifier: 限定符,修饰符
在API文档中的限定修饰符有3类: 如下图
仔细看这三类的描述会发现. 他们的注释都一模一样.
第一类Greedy Quantifiers --> 贪婪的修饰符
第二类 Reluctant quantifiers --> 不情愿的修饰符
第三类 Possessive quantifiers --> 独占的修饰符
而这三类中每一类对应的文字描述又都是一样的,那么, 他们到底有什么区别呢? 看下面的例子:
- 第一类Greedy Quantifiers --> 贪婪的修饰符 运行结果: 0-10 结果分析: 运行结果: 0-10 Greedy Quanlifiers --贪婪的修饰符 工作原理 为什么叫她贪婪的呢? 因为, 他在匹配的时候首先匹配3-10个任意字符. 他会去自动匹配最多字符,10个. 这就是为什么说他是贪婪的原因 当匹配了10个字符以后, 发现不满足条件, 于是他减少一个, 看看是否满足条件, 如果满足,就直接反悔了
String str = "aaaa9bbbb8";
//贪婪的修饰符--Greedy Quanlifiers
Pattern p1 = Pattern.compile("(.{3,10})[0-9]");
Matcher m1 = p1.matcher(str);
if(m1.find()){
System.out.println(m1.start() + "-" + m1.end());
}
/**
* 运行结果: 0-10
*
* 结果分析:
* Greedy Quanlifiers --贪婪的修饰符 工作原理
* 为什么叫她贪婪的呢? 因为, 他在匹配的时候首先匹配3-10个任意字符.
* 他会去自动匹配最多字符,10个. 这就是为什么说他是贪婪的原因
* 当匹配了10个字符以后, 发现不满足条件, 于是他减少一个, 看看是否满足条件, 如果满足,就直接反悔了
*/- 第二类 Reluctant quantifiers --> 不情愿的修饰符 运行结果: 0-5 结果分析: * Greedy Quanlifiers --贪婪的修饰符 工作原理 * 为什么叫她贪婪的呢? 因为, 他在匹配的时候首先匹配3-10个任意字符. * 他会去自动匹配最多字符,10个. 这就是为什么说他是贪婪的原因 * 当匹配了10个字符以后, 发现不满足条件, 于是他减少一个, 看看是否满足条件, 如果满足,就直接反悔了
//不情愿的修饰符--Reluctant Quanlifiers
String str = "aaaa9bbbb8";
Pattern p2 = Pattern.compile("(.{3,10}?)[0-9]");
Matcher m2 = p2.matcher(str);
if(m2.find()){
System.out.println(m2.start() + "-" + m2.end());
}
/**
* 运行结果: 0-5
*
* 结果分析:
* 不情愿的修饰符--Reluctant Quanlifiers 工作原理
* 仅仅是多了一个问号, 为什么结果却变成了0-5个呢
* 因为不情愿. 怎么个不情愿呢? 不是要匹配3-10个字符么, 那我就先匹配3个. 不情愿嘛.
* 匹配完3个,看看后面的字符是否符合条件.不符合, 那就在匹配四个, 四个符合了. 后面整个是一个数字.
* 所以匹配的结果就是0-5了
*/- 第三类 Possessive quantifiers --> 独占的修饰符 运行结果: not match ! 结果分析 * 不情愿的修饰符--Reluctant Quanlifiers 工作原理 * 真奇怪, 怎么返回的是不匹配呢? * Reluctant Quanlifiers是这么工作的. 你不是要匹配3-10个字符么. 我就匹配10个, 然后看是否符合条件. * 如何条件则返回, 不符合条件的话我不会减少字符, 直接返回不匹配. * * 也就是按照最大字符进行匹配, 符合条件,匹配成功, 不符合条件, 对不起, 匹配失败.
String str = "aaaa9bbbb8";
//不情愿的修饰符--Reluctant Quanlifiers
Pattern p3 = Pattern.compile("(.{3,10}+)[0-9]");
Matcher m3 = p3.matcher(str);
if(m3.find()){
System.out.println(m3.start() + "-" + m3.end());
}else{
System.out.println("not match !");
}
/**
* 运行结果: not match!
*
* 不情愿的修饰符--Reluctant Quanlifiers 工作原理
* 真奇怪, 怎么返回的是不匹配呢?
* Reluctant Quanlifiers是这么工作的. 你不是要匹配3-10个字符么. 我就匹配10个, 然后看是否符合条件.
* 如何条件则返回, 不符合条件的话我不会减少字符, 直接返回不匹配.
*
* 也就是按照最大字符进行匹配, 符合条件,匹配成功, 不符合条件, 对不起, 匹配失败.
*
*/9. 非捕获组-non capturing
什么是非捕获组呢? 看看下面的案例
-
- (?=x) API的解释 X, via zero-width positive lookahead. 这个解释不是很清楚, 我们来看案例 a) 下面这个案例是没有使用非捕获组. 匹配3个任意字符 输出结果 这个案例很简单. 为使用捕获组做个铺垫 2) 在上一个案例的基础上。有了新的要求， 要求第三个字符必须是数字2. 我们用常规思想如何实现呢？修改正则表达式
Pattern p11 = Pattern.compile(".{2}2");
String str11 = "ab2dd4";
Matcher m11 = p11.matcher(str11);
while(m11.find()){
System.out.println(m11.group());
}/**
* non capturing--非捕获组
* 什么是非捕获组呢? 我们来看看下面的案例
*/
/* 那么现在我提升需求: 要求打印出来的字符必须以数字2结尾.
* 能够想到的做法是什么?
* 正则表达式改为".{2}2", 这个肯定没问题
* 我们还有一种方法,使用非捕获组 (?=X)
*
* 我们知道?匹配的是0个或者1个字符. 当?在一个组中作为开头的时候, 表示的是非捕获组
*
* 来看看下面你的demo
*/
Pattern p2 = Pattern.compile(".{3}(?=2)");
String str2 = "ab2dd4";
Matcher m2 = p2.matcher(str2);
while(m2.find()){
System.out.println(m2.group());
}Pattern p3 = Pattern.compile(".{3}(?=2)");
String str3 = "abc2dd4";
Matcher m3 = p3.matcher(str3);
while(m3.find()){
System.out.println(m3.group());
}Pattern p4 = Pattern.compile("(?=2).{3}");
String str4 = "abc2dd4";
Matcher m4 = p4.matcher(str4);
while(m4.find()){
System.out.println(m4.group());
}/**
* .{3}(?!2)含义: 3个任意字符,后面跟着的不是2.
*/
Pattern p6 = Pattern.compile(".{3}(?!2)");
String str6 = "abc2dd4";
Matcher m6 = p6.matcher(str6);
while(m6.find()){
System.out.println(m6.group());
}/**
* (?<=2)含义: 与(?=2)的含义正好相反.
*
* (?=2).{3} :任意3个字符, 以2开头
* (?<=2).{3}:任意3个字符, 前面一个字符是2
*
* .{3}(?=2): 任意三个字符, 后面紧跟着的一个字符是2
* .{3}(?<=2): 任意三个字符, 三个字符中最后一个字符是2
*
* 看下面的例子
*
*/
System.out.println("=====(?=2)在前======");
Pattern p7 = Pattern.compile("(?=2).{3}");
String str7 = "abc2dd4";
Matcher m7 = p7.matcher(str7);
while(m7.find()){
System.out.println(m7.group());
}
System.out.println("=====(?<=2)在前======");
Pattern p8 = Pattern.compile("(?<=2).{3}");
String str8 = "abc2dd4";
Matcher m8 = p8.matcher(str8);
while(m8.find()){
System.out.println(m8.group());
}
System.out.println("=====(?=2)在后======");
Pattern p9 = Pattern.compile(".{3}(?=2)");
String str9 = "abc2dd4";
Matcher m9 = p9.matcher(str9);
while(m9.find()){
System.out.println(m9.group());
}
System.out.println("=====(?<=2)在后======");
Pattern p10 = Pattern.compile(".{3}(?<=2)");
String str10 = "abc2dd4";
Matcher m10 = p10.matcher(str10);
while(m10.find()){
System.out.println(m10.group());
}
=====(?=2)在前======
2dd
=====(?<=2)在前======
dd4
=====(?=2)在后======
abc
=====(?<=2)在后======
bc2 /**
*
* (?<!2)的含义: 与(?!2)的含义正好想法
* !2表示的是不是2
*
* (?!2).{3} :任意三个字符,这三个字符中第一个字符不是2
* .{3}(?!2): 任意三个字符, 这三个字符后面跟着的不是2
*
* (?<!2).{3}:任意三个字符, 这三个字符的前一个字符不是2
*
* .{3}(?<!2): 任意三个字符, 这三个字符中最后一个不是2
*
* 看下面的例子
*
*/
System.out.println("=====(?!2)在前======");
Pattern p77 = Pattern.compile("(?!2).{3}");
String str77 = "abc2dd4";
Matcher m77 = p77.matcher(str77);
while(m77.find()){
System.out.println(m77.group());
}
System.out.println("=====(?<!2)在前======");
Pattern p88 = Pattern.compile("(?<!2).{3}");
String str88 = "abc2dd4";
Matcher m88 = p88.matcher(str88);
while(m88.find()){
System.out.println(m88.group());
}
System.out.println("=====(?!2)在后======");
Pattern p99 = Pattern.compile(".{3}(?!2)");
String str99 = "abc2dd4";
Matcher m99 = p99.matcher(str99);
while(m99.find()){
System.out.println(m99.group());
}
System.out.println("=====(?<!2)在后======");
Pattern p100 = Pattern.compile(".{3}(?<!2)");
String str100 = "abc2dd4";
Matcher m100 = p100.matcher(str100);
while(m100.find()){
System.out.println(m100.group());
}=====(?!2)在前======
abc
dd4
=====(?<!2)在前======
abc
2dd
=====(?!2)在后======
bc2
dd4
=====(?<!2)在后======
abc
2ddPattern p1 = Pattern.compile(".{3}");
String str1 = "ab2dd4";
Matcher m1 = p1.matcher(str1);
while(m1.find()){
System.out.println(m1.group());
}-
- 10. 向前引用 --back refenerence, 看例子, 了解其含义 运行结果: 如果字符串变成1234,那么返回的结果就是ifalse了
System.out.println("=====back Refenences:======");
Pattern p110 = Pattern.compile("(\d\d)\1");
String str110 = "1234";
Matcher m110 = p110.matcher(str110);
System.out.println(m110.matches());=====back Refenences:======
false/**
* back Refenences:向前引用
* "(\d(\d))\2" : 正则表达式的含义, 有两个组, 后面的内容和第二组的内容保持一致
*/
System.out.println("=====back Refenences:======");
Pattern p110 = Pattern.compile("(\d(\d))\2");
String str110 = "122";
Matcher m110 = p110.matcher(str110);
System.out.println(m110.matches());/**
* back Refenences:向前引用
* \1 表示的是第一组, 表示和第一组的内容保持一致
*/
System.out.println("=====back Refenences:======");
Pattern p110 = Pattern.compile("(\d\d)\1");
String str110 = "1212";
Matcher m110 = p110.matcher(str110);
System.out.println(m110.matches());
/**
* "(\d\d)\1" : (\d\d)表示的是一个组, 这个组里有两个数字. \1,表示的是, 后面跟着的数组和第一组一致
* 来看字符串1212: 两个数字匹配到12. 后面的字符串要和第一个组一致. 所以也是12. 匹配成功
*/
- js行内式遇到的一些问题 DOM对象和jq对象转换的问题
- JavaWeb（三）servlet
- PL/SQL 编程（三 ）程序包和包体，触发器，视图，索引
- 一次关于js事件出发机制反常的解决记录
- Java综合题目
- Ubuntu 16.04下为TITAN 1080 显卡安装驱动及Gpu版TensorFlow|深度学习
- 给新生成的节点（动态生成节点）绑定事件方法总结
- JavaWeb（四）JDBC操作Oracle
- JavaWeb（六）Listener监听器
- JSP引入 - UEditor 富文本编辑器
- JavaWeb（五）Filter过滤器
- JavaWeb（七）Cookie，EL表达式，标准标签库
- JavaWeb（八）JQuery
- 程序员如何提一个好问题
- JavaScript 教程
- JavaScript 编辑工具
- JavaScript 与HTML
- JavaScript 与Java
- JavaScript 数据结构
- JavaScript 基本数据类型
- JavaScript 特殊数据类型
- JavaScript 运算符
- JavaScript typeof 运算符
- JavaScript 表达式
- JavaScript 类型转换
- JavaScript 基本语法
- JavaScript 注释
- Javascript 基本处理流程
- Javascript 选择结构
- Javascript if 语句
- Javascript if 语句的嵌套
- Javascript switch 语句
- Javascript 循环结构
- Javascript 循环结构实例
- Javascript 跳转语句
- Javascript 控制语句总结
- Javascript 函数介绍
- Javascript 函数的定义
- Javascript 函数调用
- Javascript 几种特殊的函数
- JavaScript 内置函数简介
- Javascript eval() 函数
- Javascript isFinite() 函数
- Javascript isNaN() 函数
- parseInt() 与 parseFloat()
- escape() 与 unescape()
- Javascript 字符串介绍
- Javascript length属性
- javascript 字符串函数
- Javascript 日期对象简介
- Javascript 日期对象用途
- Date 对象属性和方法
- Javascript 数组是什么
- Javascript 创建数组
- Javascript 数组赋值与取值
- Javascript 数组属性和方法
- 最大子序列和的接口函数（2）
- 最大子序列和的接口函数（3）
- 【剑指Offer】二叉树的深度
- 运行时间中的对数
- IIC协议
- 通过例子学习编写shell
- 【redis6.0.6】redis源码慢慢学，慢慢看 -- 第三天：MakeFile
- 继续学习Shell脚本（详细）
- 将linux终端的输出信息保存到log中
- UNIX网络编程卷1（第三版）一个简单的时间获取服务器的程序
- Python数据分析实战（3）Python实现数据可视化
- xresloader转表工具链增加了一些新功能(map,oneof支持，输出矩阵，基于模板引擎的加载代码生成等)
- 数据结构之树
- UNIX网络编程卷1（第三版）套接字编程简介
- UNIX网络编程卷1（第三版）readn，writen和readline函数