正则表达式小结
正则表达式在字符串操作真的是宝藏！
正则表达式常用符号使用
正则表达式特殊符号，里面有具体的示例范本
在有+，*，？这些符号时，JAVA在匹配时是贪婪匹配，尽可能匹配到最长的字符段
示例测试
public class zhengze {
public static void main(String[] args) {
String content="asdadas1778dczxcafasfasxz1556afawragsgsdgsdgh1784arfawrarw123abcd";
//1.目标：匹配所有四个数字
//说明
//1.\\d表示一个任意的数字 其中"\\"是转义符号，用于匹配的格式，不写就报错
String regStr="\\d\\d\\d\\d";//连续四个数字
//2.创建模式对象【即正则表达式对象】
Pattern pattern=Pattern.compile(regStr);
//3.创建匹配器matcher,按照正则表达式的规则
//说明：创建匹配器matcher，按照正则表达式的规则，去匹配content
Matcher matcher=pattern.matcher(content);
//4.开始匹配
while (matcher.find()){
/* String a=matcher.group(0);
System.out.println(Integer.valueOf(a));*/
System.out.println(matcher.group(0));
}
/**
* 小括号表示分组，第一个小括号表示第一组，第二个小括号表示第二组
*/
String res1="(\\d\\d)(\\d\\d)";
Pattern pattern1=Pattern.compile(res1);
Matcher matcher1=pattern1.matcher(content);
while (matcher1.find()){
System.out.println(matcher1.group(0));
System.out.println(matcher1.group(1));
System.out.println(matcher1.group(2));
//当分组后，一段内容分为n组内容，总体内容存储在matcher.group(0)中
//其他分组小内容依次放在group(1),group(2)....中
}
String res2="[abcd]";//匹配在abcd中任意的一个字符
// String res2="[a-z]";//匹配在a-z中任意的一个字符
// String res2="[A-Z]";//匹配在A-Z中任意的一个字符
// String res2="abc";//匹配在abc字符串，默认不区分大小写
//String res2="(?i)abc";匹配在abc字符串，不区分大小写
//String res2="[0-9]";//匹配在0-9中任意的一个字符
//String res2="[^a-z]";//匹配不是a-z之间的任意一个字符
//String res2="[abcd]";//匹配在abcd中任意的一个字符
//String res2="\\D";//匹配不在0-9中任意的一个字符
//String res2="\\w";//匹配大小写英文字母，数字，下划线
//String res2="\\W";//等价于[^a-zA-Z0-9]
Pattern pattern2=Pattern.compile(res2);
Matcher matcher2=pattern2.matcher(content);
while (matcher2.find()){
System.out.println(matcher2.group(0));
//当分组后，一段内容分为n组内容，总体内容存储在matcher.group(0)中
//其他分组小内容依次放在group(1),group(2)....中
}
}
/**
* matcher.find()
*
* 1.根据指定规则，定位满足条件的子字符串，如(1998)
*
* 2.找到后，将子字符串的开始的索引记录到matcher对象的属性int[] groups;
* group[0]=0,把该子字符串的结束的索引+1的值记录到groups[1]=4
*
* 3.同时记录oldLast的值为子字符串结束的索引+1的值，即下次执行时，从4开始
*
* 每次操作都会重新覆盖一遍
*/
//[abc]表示可接收的字符，abc任意一字符匹配即可
//[^abc]表示不可接收的字符，除了abc以外的任意一字符
//[A-Z] 连字符，即表示[ABCDEFG.....Z]
}
public class 选择匹配符 {
public static void main(String[] args) {
String content="wuchena111231吴辰";
// String resStr="wu|吴";//"|"为选择匹配，表示既可以..又可以..
// String resStr="[uch]{3,}";//表示由uch中字母组成的任意长度大于3的字符串
//+使用
// String resStr="\\d+";//匹配最大连续数字，数字只要连续就跟着下去匹配
//*使用
// String resStr="1*";//匹配0个1或者多个1
//^定位符,定开头格式，$结束符
//String resStr="a1?";//匹配a或者a1,JAVA贪婪匹配，能匹配a1绝不匹配a
// String resStr="^[0-9]+[a-z]*5$";//以至少一个数字作为开头，后面接至少0个小写字母，以5作为结尾
/**
* JAVA匹配时是贪婪匹配，尽可能匹配多的字符串
*/
//String resStr="[\\d]+";
// String resStr="(\\d\\d)(\\d\\d)";//分成2组，全部存放在group(0)中，第一组在group(1)中，第二组在group(2)中
//String resStr="(?\\d\\d)(?\\d\\d)";//对分组进行命名，分别存放于group(g1)与group(g2)中
String resStr="吴辰(?:教育|老师|同学)";//开头确定，后面连接的多选
String content1="吴辰老师,吴辰教育,吴辰同学";
Pattern pattern=Pattern.compile(resStr);
Matcher matcher=pattern.matcher(content1);
while (matcher.find()){//找到格式匹配的字符串输出
System.out.println(matcher.group(0));
}
//整体匹配
System.out.println(Pattern.matches(resStr,content1));
}
} 
Matcher常用方法
下面的范例为运用正则表达式进行字符串去重，去不需要的符号
演示了
matcher.matches()方法(字符串整体匹配，只返回true与false)，
matcher.replaceAll()方法 对原文进行相应的字符串替换
matcher.start()/matcher.end() 返回字符串中查找的字符段头和尾的索引
反向内部引用"(.)\\1+"表示查找有重复的字符段
反向外部引用"$1"，与"(.)\\1+"配合使用，进行去重
public class MatcherMethod {
public static void main(String[] args) {
String content = "hello edu jack tom hello smith hello";
String resStr = "hello";
Pattern pattern = Pattern.compile(resStr);
Matcher matcher = pattern.matcher(content);
while (matcher.find()){//局部匹配
System.out.println("============");
System.out.println(matcher.start());//对应整个字符串对hello的索引,开头和结尾对应
System.out.println(matcher.end());
System.out.println("找到："+content.substring(matcher.start(),matcher.end()));//输出所有hello
}
System.out.println(matcher.matches());//整体匹配，返回false
String resStr1="hello";//需要被替代的单词
Pattern pattern1=Pattern.compile(resStr1);
Matcher matcher1=pattern1.matcher(content);
//注意
String newcontent=matcher1.replaceAll("吴辰");
//replaceall中填入需要替代的词语，不改变原有字符串，只是返回新的字符串
System.out.println(newcontent);
String content1="wuchen";
String resStr2="\\w{1,}(\\w|\\-)\\w{1,}";
Pattern pattern2 = Pattern.compile(resStr2);
Matcher matcher2 = pattern2.matcher(content1);
System.out.println(matcher2.matches());
/**
* 反向引用；例子
*/
//匹配两个连续的相同数字 (\\d)\\1
//匹配五个连续相同数字(\\d)\\1{4}
//匹配个位与千位相同，十位与百位相同的数5225，1551 (\\d)(\\d)\\2\\1
/**
* 利用正则表达式去重
*/
String content3="我我...要要...学编程";
String resStr3="\\.";
Pattern pattern3=Pattern.compile(resStr3);
Matcher matcher3=pattern3.matcher(content3);
String n1=matcher3.replaceAll("");//去除省略号
System.out.println(n1);
pattern3=Pattern.compile("(.)\\1+");//使用此方式，\\1是看是否重复(反向引用)，即输出重复的字段,(.)应该是表示任意字符
matcher=pattern3.matcher(n1);//此n1为去除省略号后的字符串
String abc= matcher.replaceAll("$1");//反向引用$1，直接去重
System.out.println(abc);
//while (matcher.find()){
// System.out.println(matcher.group(0));
// }
//去掉重复的字
Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");//一句话实现字符串去重
}
}字符串对于特定的字符进行查找和替换，并且可以省去pattern，写法更加简单
public class 字符替换 {
public static void main(String[] args) {
String content="2000年5月，JDK1.3、JDK1.4和J2SE1.3相继发布，" +
"几周后其获得了Apple公司Mac OS X的工业标准的支持。2001年9月24日，" ;
//使用正则表达式，将JDK1.3和JDK1.4替换成JDK
String s= content.replaceAll("JDK1.3|JDK1.4","JDK");//将JDK1.3，JDK1.4统一替换成JDK
System.out.println(s);
//字符匹配(省去pattern)
content="1388888888";
if(content.matches("1(3|4|8)\\d{8}")){
System.out.println("成功");
}
content="hello#abc-jack12sim~cao";
String S[]=content.split("#|,|-|~");
for (String a:S) {
System.out.println(a);
}
}
}
特殊字符
牛刀小试
正则表达式在字符串中的应用：部分匹配
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.math.BigInteger;
class Solution {
public int myAtoi(String str) {
String pattern = "^\\s*([+-]?\\d+)";
//以零个或多个空格开头(*),后跟零个或一个+-号，再跟一个以上的数字
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(str);
if (!m.find( )) return 0;
BigInteger ans = new BigInteger(m.group(1));//实现开头的去零操作
if(ans.compareTo(new BigInteger(String.valueOf(Integer.MIN_VALUE)))<0){//数据溢出
return Integer.MIN_VALUE;
}
if(ans.compareTo(new BigInteger(String.valueOf(Integer.MAX_VALUE)))>0){//数据溢出
return Integer.MAX_VALUE;
}
return ans.intValue();
}
}
正则表达式：整体匹配
import java.util.regex.Pattern;
class Solution {
private static final Pattern PATTERN = Pattern.compile("^(([a-z]+[-]?[a-z]+)|([a-z]*))[!.,]?$");
public int countValidWords(String sentence) {
int cnt = 0;
String[] tokens = sentence.split(" ");
for (String token : tokens) {
if (PATTERN.matcher(token).matches() && token.length() != 0) {
cnt++;
}
}
return cnt;
}
}
import java.util.regex.Pattern;
class Solution {
public static String validIPAddress(String queryIP) {
Pattern pattern = Pattern.compile("([0-9a-fA-F]{1,4}[:]){7}[0-9a-fA-F]{1,4}");
Pattern pattern1=Pattern.compile("([0-9]{1,3}[.]){3}[0-9]{1,3}");
if (pattern1.matcher(queryIP).matches()) {
String arr[]=queryIP.split("\\.");
for (int i = 0; i 255){
return "Neither";
}
else if(arr[i].length()>1&&arr[i].charAt(0)=='0'){
return "Neither";
}
}
return "IPv4";
}
else {
if (pattern.matcher(queryIP).matches()) {
return "IPv6";
}
return "Neither";
}
}
}