package com.joker.test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.Pattern;
public class Reigix {
public static void main(String[] args) {
String replacement = "*";
// /d的用法,匹配数字
replaceAll("023-31313000", "^\\d{3}-\\d{8}$", replacement);
// /w的用法,匹配字母、汉字、数字 ^$ 用于正则表达式的开始和结束, 如 ^\d$ 匹配"aaaa"会失败,而 ^\d{4}$ 匹配会成功、
replaceAll("table11","^\\b\\w{5}\\d{2}\\b$","?");
//{m,n} mi出现最小次数,n出现最大的次数
System.out.println("table11".replaceAll("\\d{1,2}", "*"));
System.out.println("023-31313000".replaceAll("\\d", "*"));
//? + * 都是表示 重复次数,*0或者0次以上 ,+ 1次或者1次以上,*次或0次以上 0次的情况下
System.out.println("111111111");
System.out.println("a".replaceAll("\\d?","A" ));
System.out.println("11##11".replaceAll("\\d?", replacement));
System.out.println("0".replaceAll("\\(", replacement));
replaceAll("(023)023","(\\(?\\d{3}\\)?\\d{3})|(\\(?\\d{4}\\)?\\d{4})","*");
replaceAll("(0234)0234","(\\(?\\d{3}\\)?\\d{3})|(\\(?\\d{4}\\)?\\d{4})|(\\(?\\d{5}\\)?\\d{5})","*");
replaceAll("1","(\\(?\\d{3}\\)?\\d{3})|(\\(?\\d{4}\\)?\\d{4})|\\d","*");
System.out.println("(023)(023)".replaceAll("(\\(?\\d{2,3}\\)?){2,3}", replacement));
System.out.println("(023)(023)(023)".replaceAll("(\\(?\\d{2,3}\\)?){2,3}", replacement));
// \\1的用法为后
System.out.println("(023)(023)(023)".replaceAll("(\\(?\\d{2,3}\\)?)\\1\\1", replacement));
String c ="a";
System.out.println(c.replaceAll("\\d*","A" ));
System.out.println(c.replaceAll("\\w*","A" ));
//零宽度断言 只找出位置,
//零宽度正预测先行断言(?=exp) 会去匹配 出现exp的位置,向字符串前 如匹配 seeing,会出现see*ing ,说明不包含ing本身,只找出ing这个位置
//零宽度正回顾后发断言(<?=exp) 会去匹配 出现exp的位置,向字符串后 如匹配 seeing,会出现seeing* ,说明不包含ing本身,只找出ing这个位置
System.out.println("i am daning and seeing".replaceAll("(?=ing)\\w", replacement));
System.out.println("i am daning1 and seeing1".replaceAll("\\w(?<=ing)", replacement));
System.out.println("ak12".replaceAll("ak(?!2)", replacement));
//否定意思
System.out.println("12356".replaceAll("123(?!=4)", replacement));
//否定意思
System.out.println("k223".replaceAll("(?<!k)3", replacement));
//所谓贪婪匹配,默认会去匹配最长的字符串,实际是对于正则式*中尽量多的次数的匹配(会将aXXAaxxxA作为一个字符串),故称为贪婪
System.out.println("aXXAaxxxA".replaceAll("a.*A", replacement));
//相对于贪婪匹配,在次数的表达式后加一个?,会去匹配教短的字符串,实际是对于正则式*中尽量少的次数的匹配((会将aXXA,axxxA作为两个字符串)),故称为懒惰
//其他的用法如:*? {n,}? {n,m}? +? ?? 都是在原有次数的意义上,净量少次数的匹配
System.out.println("aXXAaxxxA".replaceAll("a.*?A", replacement));
//好像不支持 open递归语法
//System.out.println("<XX<".replaceAll("(?'Open'<)\\w+(?'-Open'>)", replacement));
}
public static void replaceAll(String src,String regex,String replacement){
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(src);
System.out.println(matcher.matches());
System.out.println(matcher.replaceFirst("*"));
}
}
public static void main(String[] args) {
String replacement = "*";
// /d的用法,匹配数字
replaceAll("023-31313000", "^\\d{3}-\\d{8}$", replacement);
// /w的用法,匹配字母、汉字、数字 ^$ 用于正则表达式的开始和结束, 如 ^\d$ 匹配"aaaa"会失败,而 ^\d{4}$ 匹配会成功、
replaceAll("table11","^\\b\\w{5}\\d{2}\\b$","?");
//{m,n} mi出现最小次数,n出现最大的次数
System.out.println("table11".replaceAll("\\d{1,2}", "*"));
System.out.println("023-31313000".replaceAll("\\d", "*"));
//? + * 都是表示 重复次数,*0或者0次以上 ,+ 1次或者1次以上,*次或0次以上 0次的情况下
System.out.println("111111111");
System.out.println("a".replaceAll("\\d?","A" ));
System.out.println("11##11".replaceAll("\\d?", replacement));
System.out.println("0".replaceAll("\\(", replacement));
replaceAll("(023)023","(\\(?\\d{3}\\)?\\d{3})|(\\(?\\d{4}\\)?\\d{4})","*");
replaceAll("(0234)0234","(\\(?\\d{3}\\)?\\d{3})|(\\(?\\d{4}\\)?\\d{4})|(\\(?\\d{5}\\)?\\d{5})","*");
replaceAll("1","(\\(?\\d{3}\\)?\\d{3})|(\\(?\\d{4}\\)?\\d{4})|\\d","*");
System.out.println("(023)(023)".replaceAll("(\\(?\\d{2,3}\\)?){2,3}", replacement));
System.out.println("(023)(023)(023)".replaceAll("(\\(?\\d{2,3}\\)?){2,3}", replacement));
// \\1的用法为后
System.out.println("(023)(023)(023)".replaceAll("(\\(?\\d{2,3}\\)?)\\1\\1", replacement));
String c ="a";
System.out.println(c.replaceAll("\\d*","A" ));
System.out.println(c.replaceAll("\\w*","A" ));
//零宽度断言 只找出位置,
//零宽度正预测先行断言(?=exp) 会去匹配 出现exp的位置,向字符串前 如匹配 seeing,会出现see*ing ,说明不包含ing本身,只找出ing这个位置
//零宽度正回顾后发断言(<?=exp) 会去匹配 出现exp的位置,向字符串后 如匹配 seeing,会出现seeing* ,说明不包含ing本身,只找出ing这个位置
System.out.println("i am daning and seeing".replaceAll("(?=ing)\\w", replacement));
System.out.println("i am daning1 and seeing1".replaceAll("\\w(?<=ing)", replacement));
System.out.println("ak12".replaceAll("ak(?!2)", replacement));
//否定意思
System.out.println("12356".replaceAll("123(?!=4)", replacement));
//否定意思
System.out.println("k223".replaceAll("(?<!k)3", replacement));
//所谓贪婪匹配,默认会去匹配最长的字符串,实际是对于正则式*中尽量多的次数的匹配(会将aXXAaxxxA作为一个字符串),故称为贪婪
System.out.println("aXXAaxxxA".replaceAll("a.*A", replacement));
//相对于贪婪匹配,在次数的表达式后加一个?,会去匹配教短的字符串,实际是对于正则式*中尽量少的次数的匹配((会将aXXA,axxxA作为两个字符串)),故称为懒惰
//其他的用法如:*? {n,}? {n,m}? +? ?? 都是在原有次数的意义上,净量少次数的匹配
System.out.println("aXXAaxxxA".replaceAll("a.*?A", replacement));
//好像不支持 open递归语法
//System.out.println("<XX<".replaceAll("(?'Open'<)\\w+(?'-Open'>)", replacement));
}
public static void replaceAll(String src,String regex,String replacement){
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(src);
System.out.println(matcher.matches());
System.out.println(matcher.replaceFirst("*"));
}
}