正则表达式

正则表达式——读书笔记

字符

B	指定字符B
\xhh	十六进制值为0xhh的字符
\uhhhh	十六进制表示为0xhhhh的Unicode字符
\t	制表符Tab
\n	换行
\r	回车
\f	换页
\e	转义（Escape）

还有一些字符类

.	任意字符
[abc]	包含a,b,c的任何字符（a|b|c作用相同）
[^abc]	除了a,b,c之外的任意字符
[a-zA-Z]	从a到z或从A到Z的任何字符（范围）
[abc[hij]]	任意a、b、c、h、i、j字符（和a|b|c|h|i|j作用相同）（合并）
[a-z&&[hij]]	任意h,i,j（交）
\s	空白符（空格，tab，换行，换页，回车）
\S	非空白符
\d	数字[0-9]
\D	非数字[ ^0-9 ]
\w	单词
\W	非单词

还有一些逻辑操作符

XY	Y跟在X后面
X|Y	X或Y
(X)	捕获组。可以在表达式中用\i引用第i个捕获组

量词：描述了一个模式吸收输入文本的方式

贪婪型：会为所有可能的模式发现尽可能多的匹配。

勉强型：用问号来指定，匹配满足模式所需的最少的字符数。

占有型：当正则被应用在字符串时，他会产生很多的状态，方便在匹配失败是回溯。而”占有的“并不保存这些中间状态，因此它们可以防止回溯。

贪婪型	勉强型	占有型	如何匹配
X?	X??	X+	一个或0个X
X*	X*?	X*+	0个或多个X
X+	X+?	X++	一个或多个X
X{n}	X{n}?	X{n}+	恰好n次X
X{n,}	X{n,}?	X{n,}+	至少n次X
X{n,m}	X{n,m}?	X{n,m}+	X至少n次，且不超过m次

小测一下：

package com.kuang.study.string;                                                                                                                                                  
import java.util.regex.Matcher;                                                                
import java.util.regex.Pattern;                                                                                                                                                         
public class Hel {                                                                             
    public static void main(String[] args) {                                                   
        String str = "([http]+://[a-z]+:\\d{4}/\\w+)/(\\w+\\W\\w+[=]\\d{0,}\\W+\\w+=\\d{0,})";      
        Pattern p = Pattern.compile(str);                                                      
        String s = "http://localhost:8080/user/list?pageSize=45&&row=10";                      
        Matcher matcher = p.matcher(s);                                                        
        while(matcher.find()){                                                                 
            System.out.println(matcher.group(2));                                              
            System.out.println(matcher.group(1));                                              
            System.out.println(matcher.group(0));                                              
        }                                                                                      
    }                                                                                          
}                                                                                              

其输出结果为：

list?pageSize=45&&row=10
http://localhost:8080/user
http://localhost:8080/user/list?pageSize=45&&row=10

感觉group这个方法是根据正则表达式中的小括号来区分的，group(0)是输出一整个字符串，group(1)输出第一个小括号内的字符串,group(2)输出第二个小括号内的字符串。