正则表达

参考
正则表达式的一个
参考2

限定符

常用的限定符	方式
*	匹配前面的子表达式零次或多次
+	匹配前面的子表达式一次或多次。
?	匹配前面的子表达式零次或一次。
{n}	n 是一个非负整数。匹配确定的 n 次
{n,}	n 是一个非负整数。至少匹配n 次。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次

常用这个代替 x*，零次或多次 ≡{0,} {n，m}表示前面的最少n次最多m次

定位符

常用的定位符	方式
^	匹配输入字符串开始的位置
$	匹配输入字符串结尾的位置。
\b	匹配一个字边界，即字与空格间的位置,常用来表示一个单词
\B	非字边界匹配。

\b 字符的位置是非常重要的。如果它位于要匹配的字符串的开始，它在单词的开始处查找匹配项。如果它位于字符串的结尾，它在单词的结尾处查找匹配项
Chapter 的开头三个字符： \bCha
匹配单词 Chapter 中的字符串 ter :ter\b

元字符 参考

常用的元字符	方式
\b	与一个字边界匹配；即字与空格间的位置。
\B
\d	数字字符匹配相当于[0-9]
\D	等效于 [^0-9]
\w	等效于 [A-Za-z0-9_,与以下任意字符匹配：A-Z、a-z、0-9 和下划线]
\ W	等效于 [^A-Za-z0-9_],与除 A-Z、a-z、0-9 和下划线以外的任意字符匹配。]
[xyz]	[abc] 与“plain”中的“a”匹配,字符集，与任何一个指定字符匹配。

反向引用，类似于java正则中的group（1），便是正则第一个括号中的值

正则的表示是用 \数字 ：\1

大小写是否区分

常用的元字符	方式
(?!)	不区分大小写sensitive(?!)caseless(?!)sensitive可匹配sensitiveCaSelessSENsentive
(?-i)	关闭不区分大小写,sensitive(?-!)caseless(?-!)sensitive只能匹配sensitivecaselesssensitive

通过举例子的方式来表达

需要转移的字符总结
实际操作
1、\| ：两个\后面加|，表示匹配一个|，|属于元字符，java中\本身具有转义作用，则两次,在java中相当于前一个\是给后一个\转意的，然后在用\对|转意
2、[0-9]{1,} :表示数字 某位置上出现0-9上的数字，至少1次，{n,m},表示前面的至少出现n次最多m次
3、（） ： 表示一个子表达式的开始和结束，例如(\(\?:第)([1-9]{1,})(段\)\?)，中(\?:第)，这是一个子表达式， ([1-9]{1,})这是一个子表达式，(段\)这是一个子表达式
4、 . :匹配换行符\n之外的任何单字符、
5、^ :在方括号外，表示字符串开始位置，在方括号内表示非的意思
6、| ：或运算
7、章节的表示 ： [1-9][0-9]*
8、 .* : .表示匹配任何单字符 *表示匹配前面的字符出现0次到多次
9、匹配一行文本的结束处的文本，请在正则表达式的结束处使用 $ 字符：Chapter [1-9][0-9]{0,1}$
10、若要匹配一行文本开始处的文本，请在正则表达式的开始使用 ^ 字符: ^Chapter [1-9][0-9]{0,1}
11、匹配单词 Chapter 的开头三个字符，因为这三个字符出现字边界后面： \bCha

---

java编写正则的过程

1、写一个特殊的字符串——正则表达式如a|f。
String reg1="(\$underscore[0-9]{1,}\$)|(\$bracket[1-9]{1,}\$)";
2、将正则表达式编译成一个模板：p
Pattern pattern = Pattern.compile(reg1);
3、用模板p去匹配字符串str。
Matcher matcher=pattern.matcher(str);]
4、之后拿着这个match可以做操作
match.find（）配合appendReplacement（StringBuffer sb,string replace）迭代的方式替换原来的值
或 match.replaceFirst( string)
或match.replaceAll(string s)
或者match.find（）配合match.group(int i) 迭代的取出每次匹配到的值i=0表示整个，i=1表示正则表达式（1）（2）（3）1所括起来的值

详细内容

详细介绍java正则

Pattern对象

1、Pattern对象表示经编译的正则表达式，静态的compile( )方法负责将表示正则表达式的字符串编译成Pattern对象Pattern pattern = Pattern.compile(string regx)
2、Pattern还有一个能快速判断能否在input里面找到regex的 static boolean matches(string regex, String input)
3、以及能返回String数组的split( )方法，它能用regex把字符串分割开来，这个要查看一下
4、Pattern Pattern.compile(String regex, int flag)，这个方法后面有个flag是对正则表达式进一步加强表达

flag取值	作用
Pattern.CANON_EQ
Pattern.CASE_INSENSITIVE	这个标志能让表达式忽略大小写进行匹配
Pattern.COMMENTS	匹配时会忽略(正则表达式里的)空格字符
Pattern.DOTALL	在这种模式下，表达式'.'可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式'.'不匹配行的结束符。
Pattern.MULTILINE	在这种模式下，''和'$'分别匹配一行的开始和结束。此外，''仍然匹配字符串的开始，'$'也匹配字符串的结束。
Pattern.UNICODE_CASE	在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。
Pattern.UNIX_LINES	在这个模式下，只有'/n'才被认作一行的中止，并且与'.'，'^'，以及'$'进行匹配。

---

Matcher对象，只要给Pattern.matcher(string regx )方法传一个字符串

1、boolean matches()
2、boolean lookingAt()，lookingAt( )的意思是Pattern匹配字符串的开头
3、boolean find()，的功能是发现CharSequence里的，与pattern相匹配的多个字符序列,find( )像一个迭代器.从头到尾扫描一遍字符串.
4、boolean find(int start),find( )是带int参数的，正如你所看到的，它会告诉方法从哪里开始找
5、String group(),Group是指里用括号括起来的，能被后面的表达式调用的正则表达式，Group 0 表示整个表达式，group 1表示第一个被括起来的group
find（）可以看做递归，及从sourceString中查找查找符合正则表达式的stirng，然后group函数则显示这个值group（0）表示这个值，group（1）表示正则表达式用（）括起来的第一个值
6、reset( )相当于给find（）重新跳一个指针到头上去。 假若下面程序不reset（）则第二个while没得输出

        while(matcher.find()){
            
            System.out.println(matcher.group());
        }
        matcher.reset();
        while (matcher.find()) {
            System.out.println("进来"+matcher.group());
            
        }

要记得String类型有个replace方法，可以逐个的替换值replace(matcher.group(0), matcher.group(2))，用着个和java的正则结合起来用

---

替换操作

替换操作三种可选方法
1、replaceFirst(String replacement)将字符串里，第一个与模式相匹配的子串替换成replacement。
2、replaceAll(String replacement)，将输入字符串里所有与模式相匹配的子串全部替换成replacement。
3、appendReplacement(StringBuffer sbuf, String replacement)，一般这个要配合match.find()函数来一个

//替换第一次匹配到的(?:第1段)?为xxxx
        String source="判断$bracket0$中(?:第1段)?运用了$bracket1$$underscore0$分析$bracket0$的本质(?:第2段)?(?:第3段)?";
        //在正则加的（）（）（）后面用来group（1）,group(2),group(3)的
        String reg="(\\(\\?:第)([1-9]{1,})(段\\)\\?)";
        Pattern pattern = Pattern.compile(reg); 
        Matcher matcher=pattern.matcher(source);
        String resultTemp1=matcher.replaceFirst("xxxx");
        System.out.println(resultTemp1);

---

  //替换匹配到的(?:第1段)?为xxxx
        String source="判断$bracket0$中(?:第1段)?运用了$bracket1$$underscore0$分析$bracket0$的本质(?:第2段)?(?:第3段)?";
        //在正则加的（）（）（）后面用来group（1）,group(2),group(3)的
        String reg="(\\(\\?:第)([1-9]{1,})(段\\)\\?)";
        Pattern pattern = Pattern.compile(reg); 
        Matcher matcher=pattern.matcher(source);
        String resultTemp1=matcher.replaceAll("xxxx");
        System.out.println(resultTemp1);

---

   //取出匹配到的(?:第1段)，中的数字，并替换掉原来的(?:第1段)
        String source="判断$bracket0$中(?:第1段)?运用了$bracket1$$underscore0$分析$bracket0$的本质(?:第2段)?(?:第3段)?";
        //在正则加的（）（）（）后面用来group（1）,group(2),group(3)的
        String reg="(\\(\\?:第)([1-9]{1,})(段\\)\\?)";
        Pattern pattern = Pattern.compile(reg); 
        Matcher matcher=pattern.matcher(source);
        StringBuffer stringBuffer=new StringBuffer();
        //find递归
        while(matcher.find()){
            matcher.appendReplacement(stringBuffer, matcher.group(2));//正则表达式reg，第二个（），括起来的内容
        }
        System.out.println(stringBuffer.toString());

---

或者

String source="判断$bracket0$中(?:第1段)?运用了$bracket1$$underscore0$分析$bracket0$的本质(?:第2段)?(?:第3段)?";
        //在正则加的（）（）（）后面用来group（1）,group(2),group(3)的
        String reg="(\\(\\?:第)([1-9]{1,})(段\\)\\?)";
        Pattern pattern = Pattern.compile(reg); 
        Matcher matcher=pattern.matcher(source);
        String string=null;
        //find递归
        while(matcher.find()){
            string="("+matcher.group(2)+")";
            //利用String的类来做的replace，替换
            source=source.replace(matcher.group(0), string);        
        }
        System.out.println(source);