学习《30分钟正则入门》 总结

package com.joker.test;

import java.util.regex.Matcher;
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次的情况下
  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("*"));
 }
}