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


    一、常见的符号的介绍

    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.4 其他常见符号

    []的使用--或 说明
    [] 匹配括号中的任何一个字符
    [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("askhfdakh@asfhka.com".matches("[\w[.-]]+@[\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);
    	}
    	
    }
    
  • 相关阅读:
    面向对象初识,类名称空间,对象名称空间
    python内置函数二
    生成器、列表推导式、生成器表达式
    python内置函数一
    Error response from daemon: rpc error: code = AlreadyExists desc = name conflicts with an existing object: service myweb already exists
    centos7单机安装kafka
    一个自动化框架demo
    浅谈自动化测试
    测试的个人想法
    电子课堂6:ChangeLog-2.19
  • 原文地址:https://www.cnblogs.com/dwlovelife/p/9919392.html
Copyright © 2020-2023  润新知