字符串处理利器-正则表达式

Posted 2021-01-18 dwlovelife

正则表达式

一、常见的符号的介绍

　　1.1 预定义字符类

符号	说明
.	任何字符（与行结束符可能匹配也可能不匹配）
d	数字：[0-9]
D	非数字： [^0-9]
s	空白字符：[ x0Bf ]
S	非空白字符：[^s]
w	单词字符：[a-zA-Z_0-9]
W	非单词字符：[^w]
****	转义字符，比如""匹配"" ,"{"匹配"{"。

　　1.2 数量词

符号	说明
*	等价于｛0，｝ 匹配0至多个在它之前的字符。例如正则表达式“zo”能匹配“z”以及“zoo”；正则表达式“.”意味着能够匹配任意字符串。
+	等价于｛1，｝ 匹配前面的子表达式一次或多次。例如正则表达式9+匹配9、99、999等。
?	等价于｛0，1｝ 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。此元字符还有另外一个用途，就是表示非贪婪模式匹配，后边将有介绍
{n}	匹配确定的 n 次。例如，“e{2}”不能匹配“bed”中的“d”，但是能匹配“seed”中的两个“e”。
{n,}	至少匹配n次。例如，“e{2,}”不能匹配“bed”中的“e”，但能匹配“seeeeeeeed”中的所有“e”。
{n,m}	最少匹配 n 次且最多匹配 m 次。“e{1,3}”将匹配“seeeeeeeed”中的前三个“e”。

　　1.3 边界匹配符号

符号	说明
^	行的开头
$	行的结尾
	单词边界
B	非单词边界
A	输入的开头
G	上一个匹配的结尾
	输入的结尾，仅用于最后的结束符（如果有的话）
z	输入的结尾

　　　1.3 其他常见符号

[]的使用--或	说明
[]	匹配括号中的任何一个字符
[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）
（）的使用 -- 组`
（）	将 () 之间括起来的表达式定义为“组”(group)，并且将匹配这个表达式的字符保存到一个临时区域,这个元字符在字符串提取的时候非常有用。捕获组可以通过从左到右计算其开括号来编号。
(d)	第一组
((A)(B(C)))	第一组 ((A)(B(C))) 第二组 (A) 第三组(B(C)) 第四组(C)

二.正则表达式的示例

public class Test {
    public static void main(String[] args){
        //简单认知正则表达式的概念
        p("abc".matches("..."));
        p("a8729a".replaceAll("\d", "-"));
        
        Pattern p = Pattern.compile("[a-z]{3}");
        Matcher m = p.matcher("fgh");
        
        p(m.matches());
        
        p("fgha".matches("[a-z]{3}"));
        
        //初步认识 . * + ?
        p("----------------初步认识-----------------");
        p("a".matches("."));//true
        p("aa".matches("aa"));//true
        p("aaaa".matches("a*"));//true
        p("aaaa".matches("a+"));//true
        p("".matches("a*"));//true
        p("aaaa".matches("a?"));//false
        p("".matches("a?"));//true
        p("213442142342".matches("\d{3,100}"));//true
        p("192.168.0.aaa".matches("\d{1,3}\.\d{1,3}\.\d{1,3}"));//false
        p("192".matches("[0-2][0-9][0-9]"));
        
        //范围
        p("-------------范围------------");
        p("a".matches("[abc]"));//true
        p("a".matches("[^abc]"));//false
        p("A".matches("[a-zA-Z]"));//true
        p("A".matches("[a-z]|[A-Z]"));//true
        p("A".matches("[a-z[A-Z]]"));//true
        p("R".matches("[A-Z&&[RFG]]"));//true
        
        //认识 s w d
        /**在正则表达式里两个\会被当成一个反斜杠  **/
        p("认识 \s\w\d");
        p(" 

	".matches("\s{4}"));
        p(" ".matches("/S"));
        p("a_8".matches("\w{3}"));
        p("abc888&^%".matches("[a-z]{1,3}\d+[&^#%]+"));
        p("\".matches("\\"));
        
        
        //boundary
        p("-----------------boundary-----------------");
        p("hello sir".matches("^h.*"));
        p("hello sir".matches(".*ir$"));
        p("hello sir".matches("^h[a-z]{1,3}o\b.*"));
        p("hellosir".matches("^h[a-z]{1,3}o\b.*"));
        //white line
        p(" 
".matches("^[\s&&[^
]]*\n$"));
        
        //email
        p("----------------email--------------");
        p("[email protected]".matches("[\w[.-]][email protected][\w[.-]]+\.\w+"));
    
        //matches find lookingAt
        p("------matches find lookingAt");
        Pattern p1 = Pattern.compile("\d{3,5}");
        String s = "123-2345-234-00";
        Matcher m1 = p1.matcher(s);
        p(m1.matches());
        m1.reset();
        p(m1.find());
        //找的到 才会返回 start 起始位置 和 终止位置 找不到则报错
        p(m1.start() + "-" + m1.end());
        p(m1.find());
        p(m1.start() + "-" + m1.end());
        p(m1.find());
        p(m1.start() + "-" + m1.end());
        p(m1.find());
        
        p(m1.lookingAt());
        
        //replacement
        p("----------------replacement----------------");
        Pattern p3 = Pattern.compile("java",Pattern.CASE_INSENSITIVE);
        Matcher matcher3 = p3.matcher("java JaVa ashfaks JAVA iloveJAva youhatejAVA DAFAD");
        //p(matcher3.replaceAll("JAVA"));
        StringBuffer buf = new StringBuffer();
        int i = 1;
        while(matcher3.find()){
            if(i % 2 == 0){
                matcher3.appendReplacement(buf, "java");
            }else{
                matcher3.appendReplacement(buf, "JAVA");
            }
            i++;
        }
        matcher3.appendTail(buf);
        p(buf);
        
        //group
        p("--------------group------------");
        Pattern gp = Pattern.compile("(\d{3,5})([a-z]{2})");
        String str = "123aa-34345bb-234cc-00";
        Matcher gm = gp.matcher(str);
        while(gm.find()){
            p(gm.group());
        }
    }
    
    
    public static void p(Object o){
        System.out.println(o);
    }
    
}