一文搞懂正则表达式基础语法以及如何应用（正则表达式∧含义）居然可以这样

//1. \\d 表示一个任意的数字
String regStr=”(\\d\\d)(\\d\\d)”;

//2. 创建模式对象[即正则表达式对象]
Pattern pattern=Pattern.compile(regStr);

//3. 创建匹配器
//说明：创建匹配器 matcher， 按照 正则表达式的规则 去匹配 content 字符串
Matcher matcher=pattern.matcher(content);

//4. 开始匹配
while (matcher.find()) {
System.out.println(“找到: ” + matcher.group(0));
System.out.println(“第 1 组()匹配到的值=” + matcher.group(1));
System.out.println(“第 2 组()匹配到的值=” + matcher.group(2));
}
}
}

if (group < 0 || group > groupCount()){
throw new IndexOutOfBoundsException(“No group ” + group);
}

if ((groups[group*2]==-1) || (groups[group*2+1]==-1)){
return null;
}

return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
}

String regStr=”[a-z]”; //匹配 a-z 之间任意一个字符

String regStr=”[A-Z]”; //匹配 A-Z 之间任意一个字符

String regStr=”abc”; //匹配 abc 字符串[默认区分大小写]

String regStr=”(?i)abc”; //匹配 abc 字符串[不区分大小写]

String regStr=”[0-9]”; //匹配 0-9 之间任意一个字符

String regStr=”[^a-z]”; //匹配 不在 a-z 之间任意一个字符

String regStr=”[^0-9]”; //匹配 不在 0-9 之间任意一个字符

String regStr=”[abcd]”; //匹配 在 abcd 中任意一个字符

String regStr=”\\D”; //匹配 不在 0-9 的任意一个字符

String regStr=”\\w”; //匹配 大小写英文字母, 数字，下划线

String regStr=”\\W”; //匹配 等价于 [^a-zA-Z0-9_]

// \\s 匹配任何空白字符(空格,制表符等)
String regStr=”\\s”;

// \\S 匹配任何非空白字符 ,和\\s 刚好相反
String regStr=”\\S”;

//. 匹配出 \n 之外的所有字符,如果要匹配.本身则需要使用 \\.
String regStr=”.”;

String regStr=”a{3}”; // 表示匹配 aaa
String regStr=”1{4}”; // 表示匹配 1111
String regStr=”\\d{2}”; // 表示匹配 两位的任意数字字符

//细节：java 匹配默认贪婪匹配，即尽可能匹配多的
String regStr=”a{3,4}”; //表示匹配 aaa 或者 aaaa
String regStr=”1{4,5}”; //表示匹配 1111 或者 11111
String regStr=”\\d{2,5}”; //匹配 2 位数或者 3,4,5

//1+
String regStr=”1+”; //匹配一个 1 或者多个 1
String regStr=”\\d+”; //匹配一个数字或者多个数字

//1*
String regStr=”1*”; //匹配 0 个 1 或者多个 1

//遵守贪婪匹配
String regStr=”a1?”; //匹配 a 或者 a1

String content=”123-abc”;

//以至少 1 个数字开头，后接任意个小写字母的字符串
String regStr=”^[0-9]+[a-z]*”;

//以至少 1 个数字开头, 必须以至少一个小写字母结束
String regStr=”^[0-9]+\\-[a-z]+$”;

//表示匹配边界的 han[这里的边界是指：被匹配的字符串最后,也可以是空格的子字符串的后面]
String regStr=”han\\b”;

//和\\b 的含义刚刚相反
String regStr=”han\\B”;

//命名分组： 即可以给分组取名
String regStr=”(?<g1>\\d\\d)(?<g2>\\d\\d)”;//匹配 4 个数字的字符串

Pattern pattern=Pattern.compile(regStr);
Matcher matcher=pattern.matcher(content);

while (matcher.find()) {
System.out.println(“找到=” + matcher.group(0));
System.out.println(“第 1 个分组内容=” + matcher.group(1));
System.out.println(“第 1 个分组内容[通过组名]=” + matcher.group(“g1”));
System.out.println(“第 2 个分组内容=” + matcher.group(2));
System.out.println(“第 2 个分组内容[通过组名]=” + matcher.group(“g2”));
}

//String regStr=”hello”;

String regStr=”hello.*”;

boolean matches=Pattern.matches(regStr, content);

System.out.println(“整体匹配=” + matches);
}
}

String regStr=”hello”;

Pattern pattern=Pattern.compile(regStr);

Matcher matcher=pattern.matcher(content);

while (matcher.find()) {
System.out.println(matcher.start());
System.out.println(matcher.end());
System.out.println(“找到: ” + content.substring(matcher.start(), matcher.end()));
}

//整体匹配方法，常用于，去校验某个字符串是否满足某个规则
System.out.println(“整体匹配=” + matcher.matches());

//完成如果 content 有 edu 替换成 努力学习
regStr=”edu”;
pattern=Pattern.compile(regStr);
matcher=pattern.matcher(content);

//注意：返回的字符串才是替换后的字符串 原来的 content 不变化
String newContent=matcher.replaceAll(“努力学习”);

System.out.println(“newContent=” + newContent);
System.out.println(“content=” + content);
}
}

//1. 去掉所有的.
Pattern pattern=Pattern.compile(“\\.”);
Matcher matcher=pattern.matcher(content);
content=matcher.replaceAll(“”);

//2. 去掉重复的字 我我要学学学学编程 java！
//(1) 使用 (.)\\1+
//(2) 使用 反向引用$1 来替换匹配到的内容
// 注意：因为正则表达式变化，所以需要重置 matcher

pattern=Pattern.compile(“(.)\\1+”);//分组的捕获内容记录到$1

matcher=pattern.matcher(content);

//使用 反向引用$1 来替换匹配到的内容
content=matcher.replaceAll(“$1”);

System.out.println(“content=” + content);
}
}

//使用正则表达式方式，将 JDK1.3 和 JDK1.4 替换成 JDK
content=content.replaceAll(“JDK1\\.3|JDK1\\.4”, “JDK”);

System.out.println(content);

if (content.matches(“1(38|39)\\d{8}”)) {
System.out.println(“验证成功”);
} else {
System.out.println(“验证失败”);
}

String[] split=content.split(“#|-|~|\\d+”);

for (String s : split) {
System.out.println(s);
}