底层保存的是匹配到的子字符串的 开始位置 和 结束位置+1
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
*/
public class RegExp {
public static void main(String[] args) {
String content = "1998年12月8日,第二代Java平台的企业版J2EE发布。" +
"1999年6月,Sun公司发布了第二代Java平台(简称为Java2)的3个版本" +
":J2ME(Java2 Micro Edition,Java2平台的微型版),应用于移动、" +
"无线及有限资源的环境;J2SE(Java 2 Standard Edition,Java 2平台的标准版)," +
"应用于桌面环境;J2EE(Java 2Enterprise Edition,Java 2平台的企业版)," +
"应用于基于Java的应用服务器。Java 2平台的发布," +
"是Java发展过程中最重要的一个里程碑,标志着Java的应用开始普及。9999";
//匹配所有四个数字
//说明:
// \\d:表示任意0-9 的数字 ,此处4个,表示连续在一起的四个数,
// 如果有超过连续4个的数字,只会截取前四位
String regStr = "\\d\\d\\d\\d";
//创建模式对象 正则表达式对象
Pattern compile = Pattern.compile(regStr);
//创建匹配器 matcher
//按照正则表达式的规则去匹配content字符转
Matcher matcher = compile.matcher(content);
//开始匹配
//matcher.find():会记录匹配到的字符串,开始位置索引 groups[0]=开始位置 与 结束位置索引+1 groups[1]=结束位置+1
while (matcher.find()) {
//matcher.group(0) 拿到开始位置与结束位置,去content字符串中截取
//subString (0,4),(开始索引,结束索引+1)
System.out.println(matcher.group(0));
}
}
}
分组()
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
*/
public class RegExp {
public static void main(String[] args) {
String content = "1998年12月8日,第二代Java平台的企业版J2EE发布。" +
"1999年6月,Sun公司发布了第二代Java平台(简称为Java2)的3个版本" +
":J2ME(Java2 Micro Edition,Java2平台的微型版),应用于移动、" +
"无线及有限资源的环境;J2SE(Java 2 Standard Edition,Java 2平台的标准版)," +
"应用于桌面环境;J2EE(Java 2Enterprise Edition,Java 2平台的企业版)," +
"应用于基于Java的应用服务器。Java 2平台的发布," +
"是Java发展过程中最重要的一个里程碑,标志着Java的应用开始普及。999999";
//匹配所有四个数字
//说明:
// \\d:表示任意0-9 的数字 ,此处4个,表示连续在一起的四个数,
// 如果有超过连续4个的数字,只会截取前四位
String regStr = "(\\d\\d)(\\d\\d)";
//创建模式对象 正则表达式对象
Pattern compile = Pattern.compile(regStr);
Matcher matcher = compile.matcher(content);
while (matcher.find()) {
//如果正则表达式有()就表示分组
//取出匹配规则如下
//group[0],表示匹配到的子字符串(整体)
//group[1]表示匹配到的子字符串(第一组)
//group[2]表示匹配到的子字符串(第二组)
//........
System.out.println("整体"+matcher.group(0));
System.out.println("第一组"+matcher.group(1));
System.out.println("第二组"+matcher.group(2));
}
}
}
元字符-字符匹配
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
* 字符匹配符
*/
public class RegExp {
public static void main(String[] args) {
String content = "abcM12456ABC";
//匹配a-z小写的任意 一个 字符 结果找到三个 a b d
String regStr = "[a-z]";
//java默认匹配区分大小写 结果 abc
String abc = "abc";
//不区分大小写结果abc 和ABC
String abcABC = "(?i)abc";
//创建模式对象 正则表达式对象
Pattern compile = Pattern.compile(abcABC);
Matcher matcher = compile.matcher(content);
while (matcher.find()) {
System.out.println("找到"+matcher.group(0));
}
}
}
选择匹配符
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
* 选择匹配符
*/
public class RegExp {
public static void main(String[] args) {
String content = "于124鱼56yu";
//结果找打三个 于 鱼 yu
String regStr = "于|鱼|yu";
Pattern compile = Pattern.compile(regStr);
Matcher matcher = compile.matcher(content);
while (matcher.find()) {
System.out.println("找到"+matcher.group(0));
}
}
}
元字符-限定字符
如果没有() 限定符作用于前一个字符
例如:abc? -----?针对的只有c
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
* 限定符使用
*/
public class RegExp {
public static void main(String[] args) {
String content = "aaaabcddd111111131";
//表示匹配3个d 等价于 ddd
String regStr = "d{3}";
//匹配4个1 1111
String regStr1 = "1{4}";
//陪陪两位任意数字 11,11,11,13
String regStr2 = "\\d{2}";
//匹配aa或者aaa
//java默认是贪婪匹配,优先匹配多的
//所以结果是aaa
//如果字符串有5个a匹配的结果就是aaa和aa
String regStr3 = "a{2,3}";
String content1 = "abcd1234567";
//匹配2位数字或者3位,4,5位
//结果是12345,67
//开始匹配位数是5位数,结束位数是2-5之间
String regStr4 = "\\d{2,5}";
//匹配a1或者a
String content2 = "a1b1a";
String regStr5 = "a1?";
Pattern compile = Pattern.compile(regStr5);
Matcher matcher = compile.matcher(content2);
while (matcher.find()) {
System.out.println("找到"+matcher.group(0));
}
}
}
元字符-定位符
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
* 定位符使用
*/
public class RegExp {
public static void main(String[] args) {
String content2 = "123-abc";
//必须以一个数字开头 字母结尾,数字和字母之前用连接符号-
String regStr5 = "^[0-9]+\\-[a-z]+$";
Pattern compile = Pattern.compile(regStr5);
Matcher matcher = compile.matcher(content2);
while (matcher.find()) {
System.out.println("找到"+matcher.group(0));
}
}
}
分组
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
* 分组
*/
public class RegExp {
public static void main(String[] args) {
String content2 = "abc1234符 5678";
//非命名分组
//说明
//matcher.group(0)得到匹配中的子字符串,1234,5678
//matcher.group(1)等到匹配字符串的第一个内容12和56
//matcher.group(2)等到匹配字符串的第二个内容34和78
String regStr5 = "(\\d\\d)(\\d\\d)";
Pattern compile = Pattern.compile(regStr5);
Matcher matcher = compile.matcher(content2);
while (matcher.find()) {
System.out.println("找到"+matcher.group(0));
System.out.println("找到"+matcher.group(1));
System.out.println("找到"+matcher.group(2));
}
}
}
命名分组
非捕获分组
public class Main {
public static void main(String[] args) {
String str = "于大王a于老大1于老师,于天使,于天师23456";
//非捕获分组 注意:不可以用 matcher.group(1)去捕获
//于大王,于老大,于老师,于天使,于天师
String regExp = "于(?:大王|老大|老师|天使|天师)";
//结果 于,于
// 不显示括号中的大王,老大
//非捕获
String regExp1 = "于(?=大王|老大)";
Pattern compile = Pattern.compile(regExp1);
Matcher matcher = compile.matcher(str);
while (matcher.find()) {
System.out.println(matcher.group(0));
}
}
}
非贪婪匹配
/**
* @param
* @Method
* @Author charsming
* @Version 1.0
* @Description 非贪婪匹配
* @Return
* @Date 2021/12/11 16:02
*/
public class Main {
public static void main(String[] args) {
String str = "hello111111abcd";
//结果是111111
//默认是贪婪匹配
String regExp = "\\d+";
//结果是获取到6次 一个1
//1,1,1,1,1,1
//加一个? 非贪婪匹配,尽可能匹配少的的字符
String regExp1 = "\\d+?";
Pattern compile = Pattern.compile(regExp1);
Matcher matcher = compile.matcher(str);
while (matcher.find()) {
System.out.println(matcher.group(0));
}
}
}
简单案例
/**
* @param
* @Method
* @Author charsming
* @Version 1.0
* @Description 案例
* @Return
* @Date 2021/12/11 16:02
*/
public class Main {
public static void main(String[] args) {
String str = "天道酬勤";
//^$ 开始结束表示整体匹配
//匹配全是汉字
//如果不用+号,只能匹配一个
String regExp1 = "^[\u0391-\uffe5]+$";
String str1 = "123456";
//匹配1到9开头的一个 5到10位数字
//^[1-9]匹配开头第一个字符,
//\\d{4,9}匹配结尾后
//注意不是{5,10}这样就是11位数了
String regExp2 = "^[1-9]\\d{4,9}+$";
//必须是13,14,15,18开头的11位数字
///匹配第一个,[3|4|5|8]匹配第二位数
String regExp3 = "^1[3|4|5|8]\\d{9}+$";
Pattern compile = Pattern.compile(regExp2);
Matcher matcher = compile.matcher(str1);
while (matcher.find()) {
System.out.println(matcher.group(0));
}
}
}
反向引用
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
* 反向引用
*/
public class RegExp {
public static void main(String[] args) {
String content2 = "abc1134符 55555678-1315";
//找到两个联系相同的数字
//结果11
String regStr5 = "(\\d)\\1";
//找到连续五个相同的数字 55555
String regStr6 = "(\\d)\\1{4}";
//找到第一位与第三位相同的四位数字
//结果5555,和1315
String regStr7 = "(\\d)(\\d)\\1(\\d)";
Pattern compile = Pattern.compile(regStr7);
Matcher matcher = compile.matcher(content2);
while (matcher.find()) {
System.out.println("找到" + matcher.group(0));
;
}
}
}
案例去重利用反向引用
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author
* @create 2021-12-06 21:02
* 反向引用
*/
public class RegExp {
public static void main(String[] args) {
String content2 = "我我.....要要.....学学学...编编.程";
//结果我我要要学学学编编程
String regStr7 = "\\.";
Pattern compile = Pattern.compile(regStr7);
Matcher matcher = compile.matcher(content2);
//matcher.replaceAll()替换匹配到的字符串,并返回新的字符串
String newContent = matcher.replaceAll("");
System.out.println(newContent);
//去掉重复字
//1.(.)\\1+
//2.使用反向引用$1来替换匹配到的内容
//譬如 匹配到我我, $1 是我我,字符串的开始位置 我,直接替换捕获的字符串 我我,最终把捕获的字符串变成我
//结果 我要学编程
String regStr8 = "(.)\\1+";
compile = Pattern.compile(regStr8);
Matcher matcher1 = compile.matcher(newContent);
String newCon = matcher1.replaceAll("$1");
System.out.println(newCon);
}
}
字符串直接使用正则表达式
public class RegExp {
public static void main(String[] args) {
//按照-,#,~和数字分割字符串
String content = "hello#abc~yu-haha88要发";
String[] split = content.split("-|#|~|\\d+");
System.out.println(Arrays.asList(split).toString());
}
}