正则表达式总结

最新推荐文章于 2023-06-29 17:46:09 发布

lhx060288

最新推荐文章于 2023-06-29 17:46:09 发布

阅读量377

点赞数

分类专栏：正则表达式

正则表达式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

转义字符	意义	ASCII码值（十进制）
\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符''\'	092
\'	代表一个单引号（撇号）字符	039
\"	代表一个双引号字符	034
\0	空字符(NULL)	000
\ddd	1到3位八进制数所代表的任意字符	三位八进制
\xhh	1到2位十六进制所代表的任意字符	二位十六进制

注意：区分，斜杠："/" 与反斜杠："\" ,此处不可互换

表 1.1 正则表达式语法

元字符	说明
.	匹配任何单个字符。例如正则表达式“ b.g ”能匹配如下字符串：“ big ”、“ bug ”、“ b g ”，但是不匹配“ buug ”。
$	匹配行结束符。例如正则表达式“ EJB$ ” 能够匹配字符串“ I like EJB ”的末尾，但是不能匹配字符串“ J2EE Without EJBs ！”。
^	匹配一行的开始。例如正则表达式“ ^Spring ”能够匹配字符串“ Spring is a J2EE framework ”的开始，但是不能匹配“ I use Spring in my project ”。
*	匹配 0 至多个在它之前的字符。例如正则表达式“ zo* ”能匹配 “ z ” 以及 “ zoo ”；正则表达式“ .* ”意味着能够匹配任意字符串。
\	转义符，用来将元字符当作普通的字符来进行匹配。例如正则表达式 /$ 被用来匹配美元符号，而不是行尾；正则表达式 /. 用来匹配点字符，而不是任何字符的通配符。
[]	匹配括号中的任何一个字符。例如正则表达式“ b[aui]g ”匹配 bug 、 big 和 bug ，但是不匹配 beg 。可以在括号中使用连字符“ - ”来指定字符的区间来简化表示，例如正则表达式 [0-9] 可以匹配任何数字字符，这样正则表达式“ a[]c ”就可以匹配“ a0c ”、“ a1c ”、“ a2c ”等字符串；还可以制定多个区间，例如“ [A-Za-z] ”可以匹配任何大小写字母。还有一个相配合使用的元字符“ ^ ”，用在这里并不像前边的那个“ ^ ”一样表示匹配行开始，而是表示 “ 排除 ” ，要想匹配除了指定区间之外的字符，就可以在左边的括号和第一个字符之间使用 ^ 字符，例如“ [^163A-Z] ”将能偶匹配除了 1 、 6 、 3 和所有大写字母之外的任何字符。
( )	将 () 之间括起来的表达式定义为 “ 组 ”(group) ，并且将匹配这个表达式的字符保存到一个临时区域 , 这个元字符在字符串提取的时候非常有用。
\|	将两个匹配条件进行逻辑 “ 或 ” 运算。 'z\|food' 能匹配 "z" 或 "food" 。 '(z\|f)ood' 则匹配 "zood" 或 "food" 。
+	匹配前面的子表达式一次或多次。例如正则表达式 9+ 匹配 9 、 99 、 999 等。
?	匹配前面的子表达式零次或一次。例如， "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 ”。

/\{\{(.+?)\}\}/g
 
最前面的“/”与最后面的“/”是分隔符，表示正则表达式的开始与结束。
 
最后的“g”标志表示正则表达式使用的global（全局）的状态。使用 global 标志表明在被查找的字符串中搜索操作将查找所有符合的项，而不仅仅是第一个。这也被称为全局匹配。【相关的标志还有i（ignoreCase，表示忽略大小写）、m（multiline，表示允许跨行）】
 
然后我们再来看中间的主体部分：\{\{(.+?)\}\}花括号{}是正则里的限定符。但是我们这里是要找字符串里的花括号，所以前面加个“\”来表示是要找字符的花括号。“\{\{”“\}\}”就是找前后两组花括号。
 
“.”表示任意字符。“+”表示前面表达式一次乃至多次。“?”表示匹配模式是非贪婪的。
 
/\{\{(.+?)\}\}/g完整的意思就是：在全部范围内查找匹配前后有两组花括号的字符串。
 
例如：“{{}}”、“{{asdfasdfasdf56745}}”、“{{yuyuy#$%8787 9+_)(*)87 }}”

group是针对（）来说的，group（0）就是指的整个串，group（1） 指的是第一个括号里的东西，group（2）指的第二个括号里的东西。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PatternTest {
    
    public static void main(String[] args) {
        //Java中用正则表达式截取字符串中第一个出现的英文左括号之前的字符串--- 北京市
        String text = "北京市(海淀区)(朝阳区)(西城区)"; 
        Pattern pattern = Pattern.compile(".*?(?=\\()" );
        Matcher matcher = pattern.matcher(text);
        if (matcher.find()) {
            System.out.println(matcher.group(0));
        }
        //查找以Java开头,任意结尾的字符串 -- true
        Pattern pattern = Pattern.compile("^Java.*");
        Matcher matcher = pattern.matcher("Java不是人");
        boolean b= matcher.matches();
        //当条件满足时，将返回true，否则返回false
        System.out.println(b);

       //以多条件分割字符串时
        /*Java
          Hello
          World
          Java
          Hello
          World
          Sun*/
       Pattern pattern = Pattern.compile("[, |]+");
       String[] strs = pattern.split("Java Hello World  Java,Hello,,World|Sun");
       for (int i=0;i<strs.length;i++) {
           System.out.println(strs[i]);
       } 
        
        //文字替换（首次出现字符）--Java Hello World,正则表达式 Hello World
       Pattern pattern = Pattern.compile("正则表达式");
       Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");
       //替换第一个符合正则的数据
       System.out.println(matcher.replaceFirst("Java"));
       //文字替换（全部）---Java Hello World,Java Hello World
       Pattern pattern = Pattern.compile("正则表达式");
       Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");
       //替换第一个符合正则的数据
       System.out.println(matcher.replaceAll("Java"));
        //文字替换（置换字符) ---Java Hello World,Java Hello World
        Pattern pattern = Pattern.compile("正则表达式");
        Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World ");
        StringBuffer sbr = new StringBuffer();
        while (matcher.find()) {
           matcher.appendReplacement(sbr, "Java");
        }
        matcher.appendTail(sbr);
        System.out.println(sbr.toString());
        //验证是否为邮箱地址  ---true
        String str="ceponline@yahoo.com.cn";
        Pattern pattern = Pattern.compile("[\\w\\.\\-]+@([\\w\\-]+\\.)+[\\w\\-]+",Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(str);
        System.out.println(matcher.matches());
        //截取http://地址 ---http://dsds/r/n
        Pattern pattern = Pattern.compile("(http://|https://){1}[\\w\\.\\-\\:]+");
        Matcher matcher = pattern.matcher("dsdsds<http://dsds//gfgffdfd>fdf");
        StringBuffer buffer = new StringBuffer();
        while(matcher.find()){              
            buffer.append(matcher.group());        
            buffer.append("/r/n");              
            System.out.println(buffer.toString());
        } 
        //去除html标记  ---主页
        Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL);
        Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>");
        String string = matcher.replaceAll("");
        System.out.println(string);
        //查找html中对应条件字符串 ---index.html
        Pattern pattern = Pattern.compile("href=\"(.+?)\"");
        Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>");
        if(matcher.find()) {
            System.out.println(matcher.group(1));
        }
        //matcher.group的使用
         /*Group 0:World!
         Group 1:or
         Group 2:ld!
         Start 0:6 End 0:12
         Start 1:7 End 1:9
         Start 2:9 End 2:12
         Wor*/
        String str = "Hello,World! in Java.";  
        Pattern pattern = Pattern.compile("W(or)(ld!)");  
        Matcher matcher = pattern.matcher(str);  
        while(matcher.find()){  
            System.out.println("Group 0:"+matcher.group(0));//得到第0组——整个匹配  
            System.out.println("Group 1:"+matcher.group(1));//得到第一组匹配——与(or)匹配的  
            System.out.println("Group 2:"+matcher.group(2));//得到第二组匹配——与(ld!)匹配的，组也就是子表达式  
            System.out.println("Start 0:"+matcher.start(0)+" End 0:"+matcher.end(0));//总匹配的索引  
            System.out.println("Start 1:"+matcher.start(1)+" End 1:"+matcher.end(1));//第一组匹配的索引  
            System.out.println("Start 2:"+matcher.start(2)+" End 2:"+matcher.end(2));//第二组匹配的索引  
            System.out.println(str.substring(matcher.start(0),matcher.end(1)));//从总匹配开始索引到第1组匹配的结束索引之间子串——Wor  
       }
      //替换指定{}中文字 --Java目前的发展史是由1995年-2007年
      String str = "Java目前的发展史是由{0}年-{1}年";
      String[][] object={new String[]{"\\{0\\}","1995"},new String[]{"\\{1\\}","2007"}};
      System.out.println(replace(str,object));
 
      //匹配连续的相同字符
      String reg = "(.)\\1";
      String str = "aa";
  
      Pattern p = Pattern.compile(reg);
  
      Matcher m = p.matcher(str);
  
      while(m.find()) {
          System.out.println("ok");
      }
  }
      public static String replace(final String sourceString,Object[] object) {
            String temp=sourceString;    
            for(int i=0;i<object.length;i++){
                      String[] result=(String[])object[i];
               Pattern    pattern = Pattern.compile(result[0]);
               Matcher matcher = pattern.matcher(temp);
               temp=matcher.replaceAll(result[1]);
            }
            return temp;
      }
}