精华内容
下载资源
问答
  • 正则表达式已经超出了某种语言或某个系统的局限,成为被人们广为使用的工具,我们完全可以用它来解决实际开发中碰到的一些实际的问题。 一、正则表达式基础知识 1.1 句点符号 假设你在玩英文拼字游戏,想要找出三个...
  • java正则表达式实例教程,为方便java程序员的开发使用
  • 正则表达式是一种可以用于模式匹配和替换的规范,一个正则表达式就是由普通的字符(例如字符a到z)以及特殊字符(元字符)组成的文字模式,它 用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一...
  • 最近看到很多同学想要学习java正则表达式的一些知识,那么脚本之家小编就为大家介绍一下,其实正则表达式实用性很强,处理大幅文字的时候都需要用得到,语法也大同小异
  • Java 正则表达式

    2021-01-03 01:47:29
    Java 正则表达式 正则表达式定义了字符串的模式。 正则表达式可以用来搜索、编辑或处理文本。 正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。 正则表达式实例 一个字符串其实就是一个简单的正则...
  • Java正则表达式入门

    2019-04-29 13:49:19
    Java正则表达式入门
                     众所周知,在程序开发中,难免会遇到需要匹配、查找、替换、判断字符串的情况发生,而这些情况有时又比较复杂,如果用纯编码方式解决,往往会浪费程序员的时间及精力。因此,学习及使用正则表达式,便成了解决这一矛盾的主要手段。
     大家都知道,正则表达式是一种可以用于模式匹配和替换的规范,一个正则表达式就是由普通的字符(例如字符a到z)以及特殊字符(元字符)组成的文字模式,它用以描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板,将某个字符模式与所搜索的字符串进行匹配。
      自从jdk1.4推出java.util.regex包,就为我们提供了很好的JAVA正则表达式应用平台。
     
     因为正则表达式是一个很庞杂的体系,所以我仅例举些入门的概念,更多的请参阅相关书籍及自行摸索。

    // 反斜杠
    /t 间隔 ('/u0009')
    /n 换行 ('/u000A')
    /r 回车 ('/u000D')
    /d 数字 等价于[0-9]
    /D 非数字 等价于[^0-9]
    /s 空白符号 [/t/n/x0B/f/r]
    /S 非空白符号 [^/t/n/x0B/f/r]
    /w 单独字符 [a-zA-Z_0-9]
    /W 非单独字符 [^a-zA-Z_0-9]
    /f 换页符
    /e Escape
    /b 一个单词的边界
    /B 一个非单词的边界
    /G 前一个匹配的结束

    ^为限制开头
    ^java     条件限制为以Java为开头字符
    $为限制结尾
    java$     条件限制为以java为结尾字符
    .  条件限制除/n以外任意一个单独字符
    java..     条件限制为java后除换行外任意两个字符


    加入特定限制条件「[]」
    [a-z]     条件限制在小写a to z范围中一个字符
    [A-Z]     条件限制在大写A to Z范围中一个字符
    [a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符
    [0-9]     条件限制在小写0 to 9范围中一个字符
    [0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符
    [0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集)

    []中加入^后加再次限制条件「[^]」
    [^a-z]     条件限制在非小写a to z范围中一个字符
    [^A-Z]     条件限制在非大写A to Z范围中一个字符
    [^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符
    [^0-9]     条件限制在非小写0 to 9范围中一个字符
    [^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符
    [^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集)

    在限制条件为特定字符出现0次以上时,可以使用「*」
    J*     0个以上J
    .*     0个以上任意字符
    J.*D     J与D之间0个以上任意字符

    在限制条件为特定字符出现1次以上时,可以使用「+」
    J+     1个以上J
    .+     1个以上任意字符
    J.+D     J与D之间1个以上任意字符

    在限制条件为特定字符出现有0或1次以上时,可以使用「?」
    JA?     J或者JA出现

    限制为连续出现指定次数字符「{a}」
    J{2}     JJ
    J{3}     JJJ
    文字a个以上,并且「{a,}」
    J{3,}     JJJ,JJJJ,JJJJJ,???(3次以上J并存)
    文字个以上,b个以下「{a,b}」
    J{3,5}     JJJ或JJJJ或JJJJJ
    两者取一「|」
    J|A     J或A
    Java|Hello     Java或Hello
     
    「()」中规定一个组合类型
    比如,我查询<a href=/"index.html/">index</a>中<a href></a>间的数据,可写作<a.*href=/".*/">(.+?)</a>

    在使用Pattern.compile函数时,可以加入控制正则表达式的匹配行为的参数:
    Pattern Pattern.compile(String regex, int flag)

    flag的取值范围如下:
    Pattern.CANON_EQ     当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下,才认定匹配。比如用了这个标志之后,表达式"a/u030A"会匹配"?"。默认情况下,不考虑"规范相等性(canonical equivalence)"。
    Pattern.CASE_INSENSITIVE(?i)     默认情况下,大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹配,只要将UNICODE_CASE与这个标志合起来就行了。
    Pattern.COMMENTS(?x)     在这种模式下,匹配时会忽略(正则表达式里的)空格字符(译者注:不是指表达式里的"//s",而是指表达式里的空格,tab,回车之类)。注释从#开始,一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。
    Pattern.DOTALL(?s)     在这种模式下,表达式'.'可以匹配任意字符,包括表示一行的结束符。默认情况下,表达式'.'不匹配行的结束符。
    Pattern.MULTILINE
    (?m)     在这种模式下,'^'和'$'分别匹配一行的开始和结束。此外,'^'仍然匹配字符串的开始,'$'也匹配字符串的结束。默认情况下,这两个表达式仅仅匹配字符串的开始和结束。
    Pattern.UNICODE_CASE
    (?u)     在这个模式下,如果你还启用了CASE_INSENSITIVE标志,那么它会对Unicode字符进行大小写不明感的匹配。默认情况下,大小写不敏感的匹配只适用于US-ASCII字符集。
    Pattern.UNIX_LINES(?d)     在这个模式下,只有'/n'才被认作一行的中止,并且与'.','^',以及'$'进行匹配。


    抛开空泛的概念,下面写出几个简单的Java正则用例:

    ◆比如,在字符串包含验证时

    //查找以Java开头,任意结尾的字符串
      Pattern pattern = Pattern.compile("^Java.*");
      Matcher matcher = pattern.matcher("Java不是人");
      boolean b= matcher.matches();
      //当条件满足时,将返回true,否则返回false
      System.out.println(b);


    ◆以多条件分割字符串时
    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]);
    }

    ◆文字替换(首次出现字符)
    Pattern pattern = Pattern.compile("正则表达式");
    Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");
    //替换第一个符合正则的数据
    System.out.println(matcher.replaceFirst("Java"));

    ◆文字替换(全部)
    Pattern pattern = Pattern.compile("正则表达式");
    Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World");
    //替换第一个符合正则的数据
    System.out.println(matcher.replaceAll("Java"));


    ◆文字替换(置换字符)
    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());

    ◆验证是否为邮箱地址

    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());

    ◆去除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中对应条件字符串
    Pattern pattern = Pattern.compile("href=/"(.+?)/"");
    Matcher matcher = pattern.matcher("<a href=/"index.html/">主页</a>");
    if(matcher.find())
      System.out.println(matcher.group(1));
    }

    ◆截取http://地址
    //截取url
    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());
    }
           
    ◆替换指定{}中文字

    String str = "Java目前的发展史是由{0}年-{1}年";
    String[][] object={new String[]{"//{0//}","1995"},new String[]{"//{1//}","2007"}};
    System.out.println(replace(str,object));

    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;
    }


    ◆以正则条件查询指定目录下文件

     //用于缓存文件列表
            private ArrayList files = new ArrayList();
            //用于承载文件路径
            private String _path;
            //用于承载未合并的正则公式
            private String _regexp;
           
            class MyFileFilter implements FileFilter {

                  /**
                   * 匹配文件名称
                   */
                  public boolean accept(File file) {
                    try {
                      Pattern pattern = Pattern.compile(_regexp);
                      Matcher match = pattern.matcher(file.getName());               
                      return match.matches();
                    } catch (Exception e) {
                      return true;
                    }
                  }
                }
           
            /**
             * 解析输入流
             * @param inputs
             */
            FilesAnalyze (String path,String regexp){
                getFileName(path,regexp);
            }
           
            /**
             * 分析文件名并加入files
             * @param input
             */
            private void getFileName(String path,String regexp) {
                //目录
                  _path=path;
                  _regexp=regexp;
                  File directory = new File(_path);
                  File[] filesFile = directory.listFiles(new MyFileFilter());
                  if (filesFile == null) return;
                  for (int j = 0; j < filesFile.length; j++) {
                    files.add(filesFile[j]);
                  }
                  return;
                }
       
            /**
             * 显示输出信息
             * @param out
             */
            public void print (PrintStream out) {
                Iterator elements = files.iterator();
                while (elements.hasNext()) {
                    File file=(File) elements.next();
                        out.println(file.getPath());   
                }
            }

            public static void output(String path,String regexp) {

                FilesAnalyze fileGroup1 = new FilesAnalyze(path,regexp);
                fileGroup1.print(System.out);
            }
       
            public static void main (String[] args) {
                output("C://","[A-z|.]*");
            }

    Java正则的功用还有很多,事实上只要是字符处理,就没有正则做不到的事情存在。(当然,正则解释时较耗时间就是了|||……)

                
    展开全文
  • Java正则表达式入门
  • 大家都知道,正则表达式是一种可以用于模式匹配和替换的规范,一个正则表达式就是由普通的字符(例如字符a到z)以及特殊字符(元字符)组成的文字模式,它 用以描述在查找文字主体时待匹配的一个或多个字符串。正则...
  • 正则表达式Java中的DFA 这是通过使用Java语言创建和使用语法树将regex(正则表达式)转换为DFA的方法。 该项目是我们在大学第五学期(@KNTU)的编译器课程中完成的一个较大项目的一部分,以创建一个简单的编译器...
  • java正则表达式入门

    2018-04-23 22:38:34
    写在前面 介绍 基本用法 \ 的转义 字符 字符类 边界匹配符 实验 ...由于读入的信息以字符串的...由于之前并没有特意去学习过正则表达式,现在用到了,简单地分享一下我所学的正则表达式。 介绍 在学正则表达式...

    写在前面

    在做实验的时候,需要读入文件。由于读入的信息以字符串的形式存储的,并且文件是按照一定的格式进行书写的,因此要得到对应的信息,就需要匹配每个字符串,这个时候就需要用到正则表达式。由于之前并没有特意去学习过正则表达式,现在用到了,简单地分享一下我所学的正则表达式。

    介绍

    在学正则表达式之前,总要知道这个是什么,用来做什么。官方地说,正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。我对正则表达式的理解,就是用来匹配字符串的,在字符串中找到我们需要的信息,然后进行处理。其中的首要任务就是在一堆字符串,找到我们需要的子串。
    《java编程思想》中是这样描述的:

    • 正则表达式就是以某种方式来描述字符串,因此你可以说:“如果一个字符串含有这些东西,那么它就是我正在找的东西。”例如,要找一个数字,它可能有一个负号在最前面,那你就写一个负号加上一个问号,就像这样:-?

    基本用法

    我们最先知道的正则表达式工具应该是split()方法,它将字符串从正则表达式匹配的地方切开。虽然之前一直在用,但直到最近才知道它就是传说中的正则表达式。
    正则表达式有一些基本的语法:

    \ 的转义

    在学语法的时候,我们直到\ 表示转义,在java正则表达式中,也需要使用\进行转义,不过,如果要表示\ 在表达式中,需要使用双斜杠\\ 表示转义。
    例如,当需要表示一位数字的时候,正则表达式应该是\\d

    字符

      B           表示指定字符B(类似的,A就表示字符A,a就表示字符a)
    
      \n         换行(一些转义与C语言相同,,还有\t等)
    
      \xhh       `\` 后面接十六进制,表示oxhhhh的Unicode字符
    

    字符类

      .            任意字符
    
      [abc]        包含a、b和c的任何字符(等同于a|b|c)
    
      [^a]         除a以外的任何字符
    
      \s           空白字符(空格、tab、换行、换页和回车)
    

    边界匹配符

        ^          一行的起始
    
        $          一行的结束
    
        \b         词的边界
    

    语法其实还是比较多的,用到什么直接查就好了,本文并不是词典,就不一一罗列了。
    推荐查看这篇文章的语法范例。
    写到这里,大家应该对正则表达式有一个基本的概念了,那么它是如何使用的呢?下面我们进行一些代码实战。

    实验

    为了利用正则表达式,我们利用java中的regex包,利用其中的 Matcher 类和 Pattern 类,具体说明见官方文档 javaAPI。使用方法见如下代码,本文所有的代码都利用这两个类进行匹配。
    另外,再介绍一个group方法,用于取出匹配到的字符串。
    注意 :group(0)返回的是被匹配的字符串,需要从group(1)开始。

    • 最简单的匹配就是直接匹配一个字符:
    String string = "A";
    String pattern = "([a-zA-Z])";
    
    Pattern r = Pattern.compile(pattern);
    Matcher m = r.matcher(string);
    if (m.find()) {
        System.out.println("Found : " + m.group(1));
    }

    输出结果:Found : A

    • 也可以利用+的语法来匹配字符串 (+ 表示出现一次或多次)
    String string = "ABCD";
    String pattern = "([a-zA-Z]+)";
    
    Pattern r = Pattern.compile(pattern);
    Matcher m = r.matcher(string);
    if (m.find()) {
        System.out.println("Found : " + m.group(1));
    }

    Found : ABCD
    这样,我们就可以组合起来。

    • 实验中的案例:
      实验中要匹配的一种字符串为:Vertex = <\”Server1\”, \”Server\”, <\”192.168.1.2\”>>
      那么,就可以利用上面所学的知识,组合起来匹配这样的字符串,代码如下:
    String string = "Vertex = <\"Server1\", \"Server\", <\"192.168.1.2\">> ";
    String pattern = "\"([a-zA-Z0-9]+)\",\\s*\"([a-zA-Z0-9]+)\",\\s*<\"([a-zA-Z0-9.]+)\">";
    
    Pattern r = Pattern.compile(pattern);
    Matcher m = r.matcher(string);
    if (m.find()) {
        System.out.println("Found value: " + m.group(1));
        System.out.println("Found value: " + m.group(2));
        System.out.println("Found value: " + m.group(3)); 
    } else {
        System.out.println("NO MATCH");
    }

    运行结果:

    Found value: Server1
    Found value: Server
    Found value: 192.168.1.2

    注意:这里的 * 表示的是0个或多个,区别于 + 的1个或多个。

    实验中可以使用的方法很多,这只是最通俗的一种,可以根据自己的喜好随意更改。

    结论

    正则表达式是一种非常有效的处理字符串的方式,希望大家能够通过这篇文章对正则表达式有基本的认识。

    展开全文
  • Java正则表达式入门 + HTMLParser使用详解 Java正则表达式入门 + HTMLParser使用详解 Java正则表达式入门 + HTMLParser使用详解 Java正则表达式入门 + HTMLParser使用详解
  • java 正则表达式入门

    2012-02-07 09:54:51
    java 正则表达式入门 正则表达式相关操作!于含义定义的简短手册 适合快速查询回顾使用!
  • Java正则表达式入门篇(一)

    千次阅读 2020-06-09 23:41:43
    5分钟搞懂正则表达式

    导语

    正则表达式是一组描述字符串特征的字符,常用于检查某个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。各编程语言的正则表达式都有些许差别,本文主要讲解正则表达式在java语言中的简单应用,所以调用String对象的matches()方法判断是否匹配与否,并不使用Pattern类与Matche类及\d,\w等预定义字符,笔者会在入门篇(二)中介绍到。在阅读此篇时,建议对照正则表达式规则表阅读。正则表达式语法规则表

    正则表达式的语法

    标准语法:
    	[匹配规则]{数量词}
    

    环境准备

     Idea + JDK8 + regStr(正则表达式字符串) + testStr(测试字符串)
    

    使用正则表达式完成单个确定字符检验

    案例1:testStr中的字符只允许为a

    中括号中只存在单个字符时,匹配规则就是该字符,
    该案例字符只允许为a,且只允许单个字符,所以数量词是1,
    所以其正则表达式为[a]{1}
    

    Idea代码

    public static void main(String[] args) {
        String regStr = "[a]{1}"; //正则表达式字符串
        String testStr = "a";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出
    控制台输出
    当数量词为1时“{1}”可省略 ,当字符确定时 “[]” 可省略,所以以上表达式还有种简化写法

    public static void main(String[] args) {
     String regStr = "a"; //正则表达式字符串
        String testStr = "a";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    使用正则表达式完成单个不确定字符进行检验

    案例1:testStr中的字符只允许为a b c 1 2 3中的一个

    中括号存在多个字符时,匹配规则为中括号的所有字符,
    该案例字符只允许为a b c 1 2 3其中一个字符,
    所以匹配条件就是abc123,
    所以其正则表达式为[abc123]
    

    Idea代码

    public static void main(String[] args) {
        String regStr = "[abc123]"; //正则表达式字符串
        String testStr = "2";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出
    控制台输出
    案例2:testStr中的字符只允许为a b c 1 2 3之外的任意字符

    中括号中存在"^"时,中括号中的匹配规则取反,
    该案例字符只允许为a b c 1 2 3外的任意字符,
    所以匹配条件就是^abc123字符,
    所以其正则表达式为[^abc123]
    

    Idea代码

    public static void main(String[] args) {
     String regStr = "[^abc123]"; //正则表达式字符串
        String testStr = "d";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出

    控制台输出

    案例3:testStr中的字符只允许为a-z或0-9中的字符

    中括号中存在"-"时,匹配规则为被"-"连接的两个字符间的所有字符,
    该案例字符只允许为a-z或0-9中的字符,
    所以匹配条件就是a-z0-9字符,
    所以其正则表达式为[a-z0-9]
    

    Idea代码

    public static void main(String[] args) {
     String regStr = "[a-z0-9]"; //正则表达式字符串
        String testStr = "c";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出
    控制台输出

    案例4:testStr中的字符只允许为a-f或B-H中的字符

    当中括号中出现另一个中括号时,匹配规则为外层中括号中的匹配规则与内层中括号的匹配规则的并集,
    该案例字符只允许a-f或者B-H中的字符,
    所以匹配条件就是a-f和B-H字符,
    所以其正则表达式为[a-f[B-H]]
    

    Idea代码

    public static void main(String[] args) {
     String regStr = "[a-f[B-H]]"; //正则表达式字符串
        String testStr = "C";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台代码
    控制台输出

    案例5:testStr中的字符只允许为a-f和b-z中共同存在的字符

    当内层中括号前存在“&&”时,匹配规则为外层中括号中的匹配规则与内层中括号的匹配规则的交集,
    该案例字符只允许为a-f和b-z中共同存在的字符,
    所以匹配条件就是a-f和b-z字符,
    所以其正则表达式为[a-f&&[b-z]]
    

    Idea代码

    public static void main(String[] args) {
     String regStr = "[a-f&&[b-z]]"; //正则表达式字符串
        String testStr = "f";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出
    控制台输出

    使用正则表达式完成多个确定字符进行检验

    案例1:testStr中的字符只允许为aaa

    中括号中只存在单个字符时,匹配条件就是该字符,
    该案例字符只允许为aaa,
    所以其正则表达式为[a]{3}
    

    Idea代码

    public static void main(String[] args) {
     String regStr = "[a]{3}"; //正则表达式字符串
        String testStr = "f";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出
    控制台输出
    当然以上代码也可以简写为

    public static void main(String[] args) {
        String regStr = "a{3}"; //正则表达式字符串
        String testStr = "aaa";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    案例2:testStr中的字符只允许为aa1&&

    该案例字符只允许为aa1&&,
    所以其正则表达式为a{2}1&{2}
    

    Idea代码

    public static void main(String[] args) {
        String regStr = "a{2}1&{2}"; //正则表达式字符串
        String testStr = "aa1&&";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    使用正则表达式完成多个不确定字符进行检验

    案例1:testStr中的字符长度至少为16,且必须以abc开头

    在大括号中存在","时,逗号前的数量词代表该字符串的最小长度
    所以其正则表达式为abc[.]{13, }
    

    Idea代码

    public static void main(String[] args) {
        String regStr = "abc.{13,}"; //正则表达式字符串
        String testStr = "abc123456@#$%^&*";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出
    控制台输出
    案例2:testStr中的字符只允许为130 135 177 181 182 199开头的手机号

    该案例只允许为手机号 所以字符串长度为11位 且第一位只能为1
    第二位只能为 3789 第三位只能取057129 所以还剩下8位数字
    所以其正则表达式为1[3789][057129][0-9]{8}
    

    idea代码

    public static void main(String[] args) {
        String regStr = "1[3789][057129][0-9]{8}"; //正则表达式字符串
        String testStr = "13044375521";//测试字符串
        System.out.println(testStr.matches(regStr));
    }

    控制台输出
    控制台输出
    本博客文章转载,请注明出处

    展开全文
  • 正则表达式的“祖先”可以一直上溯至对人类神经系统如何工作的早期研究。Warren McCulloch 和 Walter Pitts 这两位神经生理学家研究出一种数学方式来描述这些神经网络。 1956 年, 一位叫 Stephen Kleene 的美国数学...
  • Java正则表达式入门介绍.ppt,介绍常用语法规则及使用方式等
  • 引言正则表达式(regular expression)描述了一种字符串匹配的模式,可以用来:(1)检查一个串中是否含有符合某个规则的子串,并且可以得到这个子串;(2)根据匹配规则对字符串进行灵活的替换操作.正则表达式学习起来其实是...
    引言
    正则表达式(regular expression)描述了一种字符串匹配的模式,可以用来:(1)检查一个串中是否含有符合某个规则的子串,并且可以得到这个子串;(2)根据匹配规则对字符串进行灵活的替换操作.
    正则表达式学习起来其实是很简单的,不多的几个较为抽象的概念也很容易理解.之所以很多人感觉正则表达式比较复杂,一方面是因为大多数的文档没有做到由浅入深地讲解,概念上没有注意先后顺序,给读者的理解带来困难;另一方面,各种引擎自带的文档一般都要介绍它特有的功能,然而这部分特有的功能并不是我们首先要理解的.
    文章中的每一个举例,都可以点击进入到测试页面进行测试.闲话少说,开始.
    1. 正则表达式规则
    1.1 普通字符
    字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号,都是"普通字符".表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同的一个字符.
    举例1:表达式 "c",在匹配字符串 "abcde" 时,匹配结果是:成功;匹配到的内容是:"c";匹配到的位置是:开始于2,结束于3.(注:下标从0开始还是从1开始,因当前编程语言的不同而可能不同)
    举例2:表达式 "bcd",在匹配字符串 "abcde" 时,匹配结果是:成功;匹配到的内容是:"bcd";匹配到的位置是:开始于1,结束于4.
    1.2 简单的转义字符
    一些不便书写的字符,采用在前面加 "\" 的方法.这些字符其实我们都已经熟知了.
    表达式
    可匹配
    \r, \n
    代表回车和换行符
    \t
    制表符
    \\
    代表 "\" 本身
    还有其他一些在后边章节中有特殊用处的标点符号,在前面加 "\" 后,就代表该符号本身.比如:^, $ 都有特殊意义,如果要想匹配字符串中 "^" 和"$" 字符,则表达式就需要写成 "\^" 和"\$".
    表达式
    可匹配
    \^
    匹配 ^ 符号本身
    \$
    匹配 $ 符号本身
    \.
    匹配小数点(.)本身
    这些转义字符的匹配方法与 "普通字符" 是类似的.也是匹配与之相同的一个字符.
    举例1:表达式 "\$d",在匹配字符串 "abc$de" 时,匹配结果是:成功;匹配到的内容是:"$d";匹配到的位置是:开始于3,结束于5.
    1.3 能够与 '多种字符' 匹配的表达式
    正则表达式中的一些表示方法,可以匹配 '多种字符' 其中的任意一个字符.比如,表达式 "\d" 可以匹配任意一个数字.虽然可以匹配其中任意字符,但是只能是一个,不是多个.这就好比玩扑克牌时候,大小王可以代替任意一张牌,但是只能代替一张牌.
    表达式
    可匹配
    \d
    任意一个数字,0~9 中的任意一个
    \w
    任意一个字母或数字或下划线,也就是 A~Z,a~z,0~9,_ 中任意一个
    \s
    包括空格、制表符、换页符等空白字符的其中任意一个
    .
    小数点可以匹配除了换行符(\n)以外的任意一个字符
    举例1:表达式 "\d\d",在匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"12";匹配到的位置是:开始于3,结束于5.
    举例2:表达式 "a.\d",在匹配 "aaa100" 时,匹配的结果是:成功;匹配到的内容是:"aa1";匹配到的位置是:开始于1,结束于4.
    1.4 自定义能够匹配 '多种字符' 的表达式
    使用方括号 [ ] 包含一系列字符,能够匹配其中任意一个字符.用[^ ] 包含一系列字符,则能够匹配其中字符之外的任意一个字符.同样的道理,虽然可以匹配其中任意一个,但是只能是一个,不是多个.
    表达式
    可匹配
    [ab5@]
    匹配 "a" 或"b" 或"5" 或"@"
    [^abc]
    匹配 "a","b","c" 之外的任意一个字符
    [f-k]
    匹配 "f"~"k" 之间的任意一个字母
    [^A-F0-3]
    匹配 "A"~"F","0"~"3" 之外的任意一个字符
    举例1:表达式 "[bcd][bcd]" 匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"bc";匹配到的位置是:开始于1,结束于3.
    举例2:表达式 "[^abc]" 匹配 "abc123" 时,匹配的结果是:成功;匹配到的内容是:"1";匹配到的位置是:开始于3,结束于4.
    1.5 修饰匹配次数的特殊符号
    前面章节中讲到的表达式,无论是只能匹配一种字符的表达式,还是可以匹配多种字符其中任意一个的表达式,都只能匹配一次.如果使用表达式再加上修饰匹配次数的特殊符号,那么不用重复书写表达式就可以重复匹配.
    使用方法是:"次数修饰"放在"被修饰的表达式"后边.比如:"[bcd][bcd]" 可以写成 "[bcd]{2}".
    表达式
    作用
    {n}
    表达式重复n次,比如:"\w{2}" 相当于 "\w\w";"a{5}" 相当于 "aaaaa"
    {m,n}
    表达式至少重复m次,最多重复n次,比如:"ba{1,3}"可以匹配 "ba"或"baa"或"baaa"
    {m,}
    表达式至少重复m次,比如:"\w\d{2,}"可以匹配 "a12","_456","M12344"...
    ?
    匹配表达式0次或者1次,相当于 {0,1},比如:"a[cd]?"可以匹配 "a","ac","ad"
    +
    表达式至少出现1次,相当于 {1,},比如:"a+b"可以匹配 "ab","aab","aaab"...
    *
    表达式不出现或出现任意次,相当于 {0,},比如:"\^*b"可以匹配 "b","^^^b"...
    举例1:表达式 "\d+\.?\d*" 在匹配 "It costs $12.5" 时,匹配的结果是:成功;匹配到的内容是:"12.5";匹配到的位置是:开始于10,结束于14.
    举例2:表达式 "go{2,8}gle" 在匹配 "Ads by goooooogle" 时,匹配的结果是:成功;匹配到的内容是:"goooooogle";匹配到的位置是:开始于7,结束于17.
    1.6 其他一些代表抽象意义的特殊符号
    一些符号在表达式中代表抽象的特殊意义:
    表达式
    作用
    ^
    与字符串开始的地方匹配,不匹配任何字符
    $
    与字符串结束的地方匹配,不匹配任何字符
    \b
    匹配一个单词边界,也就是单词和空格之间的位置,不匹配任何字符
    进一步的文字说明仍然比较抽象,因此,举例帮助大家理解.
    举例1:表达式 "^aaa" 在匹配 "xxx aaa xxx" 时,匹配结果是:失败.因为 "^" 要求与字符串开始的地方匹配,因此,只有当 "aaa" 位于字符串的开头的时候,"^aaa" 才能匹配,比如:"aaa xxx xxx".
    举例2:表达式 "aaa$" 在匹配 "xxx aaa xxx" 时,匹配结果是:失败.因为 "$" 要求与字符串结束的地方匹配,因此,只有当 "aaa" 位于字符串的结尾的时候,"aaa$" 才能匹配,比如:"xxx xxx aaa".
    举例3:表达式 ".\b." 在匹配 "@@@abc" 时,匹配结果是:成功;匹配到的内容是:"@a";匹配到的位置是:开始于2,结束于4.
    进一步说明:"\b" 与"^" 和"$" 类似,本身不匹配任何字符,但是它要求它在匹配结果中所处位置的左右两边,其中一边是 "\w" 范围,另一边是 非"\w" 的范围.
    举例4:表达式 "\bend\b" 在匹配 "weekend,endfor,end" 时,匹配结果是:成功;匹配到的内容是:"end";匹配到的位置是:开始于15,结束于18.
    一些符号可以影响表达式内部的子表达式之间的关系:
    表达式
    作用
    |
    左右两边表达式之间 "或" 关系,匹配左边或者右边
    ( )
    (1). 在被修饰匹配次数的时候,括号中的表达式可以作为整体被修饰
    (2). 取匹配结果的时候,括号中的表达式匹配到的内容可以被单独得到
    举例5:表达式 "Tom|Jack" 在匹配字符串 "I'm Tom, he is Jack" 时,匹配结果是:成功;匹配到的内容是:"Tom";匹配到的位置是:开始于4,结束于7.匹配下一个时,匹配结果是:成功;匹配到的内容是:"Jack";匹配到的位置时:开始于15,结束于19.
    举例6:表达式 "(go\s*)+" 在匹配 "Let's go go go!" 时,匹配结果是:成功;匹配到内容是:"go go go";匹配到的位置是:开始于6,结束于14.
    举例7:表达式 "¥(\d+\.?\d*)" 在匹配 "$10.9,¥20.5" 时,匹配的结果是:成功;匹配到的内容是:"¥20.5";匹配到的位置是:开始于6,结束于10.单独获取括号范围匹配到的内容是:"20.5".
    2. 正则表达式中的一些高级规则
    2.1 匹配次数中的贪婪与非贪婪
    在使用修饰匹配次数的特殊符号时,有几种表示方法可以使同一个表达式能够匹配不同的次数,比如:"{m,n}", "{m,具体匹配的次数随被匹配的字符串而定.这种重复匹配不定次数的表达式在匹配过程中,总是尽可能多的匹配.比如,针对文本 "dxxxdxxxd",举例如下:
    表达式
    匹配结果
    (d)(\w+)
    "\w+" 将匹配第一个 "d" 之后的所有字符 "xxxdxxxd"
    (d)(\w+)(d)
    "\w+" 将匹配第一个 "d" 和最后一个 "d" 之间的所有字符 "xxxdxxx".虽然 "\w+" 也能够匹配上最后一个 "d",但是为了使整个表达式匹配成功,"\w+" 可以 "让出" 它本来能够匹配的最后一个 "d"
    由此可见,"\w+" 在匹配的时候,总是尽可能多的匹配符合它规则的字符.虽然第二个举例中,它没有匹配最后一个 "d",但那也是为了让整个表达式能够匹配成功.同理,带"*" 和"{m,n}" 的表达式都是尽可能地多匹配,带"?" 的表达式在可匹配可不匹配的时候,也是尽可能的 "要匹配".这 种匹配原则就叫作 "贪婪" 模式 .
    非贪婪模式:
    在修饰匹配次数的特殊符号后再加上一个 "?" 号,则可以使匹配次数不定的表达式尽可能少的匹配,使可匹配可不匹配的表达式,尽可能的 "不匹配".这种匹配原则叫作 "非贪婪" 模式,也叫作 "勉强" 模式.如果少匹配就会导致整个表达式匹配失败的时候,与贪婪模式类似,非贪婪模式会最小限度的再匹配一些,以使整个表达式匹配成功.举例如下,针对文本 "dxxxdxxxd" 举例:
    表达式
    匹配结果
    (d)(\w+?)
    "\w+?" 将尽可能少的匹配第一个 "d" 之后的字符,结果是:"\w+?" 只匹配了一个 "x"
    (d)(\w+?)(d)
    为了让整个表达式匹配成功,"\w+?" 不得不匹配 "xxx" 才可以让后边的 "d" 匹配,从而使整个表达式匹配成功.因此,结果是:"\w+?" 匹配 "xxx"
    更多的情况,举例如下:
    举例1:表达式 "<td>(.*)</td>" 与字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配时,匹配的结果是:成功;匹配到的内容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整个字符串, 表达式中的 "</td>" 将与字符串中最后一个 "</td>" 匹配.
    举例2:相比之下,表达式 "<td>(.*?)</td>" 匹配举例1中同样的字符串时,将只得到 "<td><p>aa</p></td>", 再次匹配下一个时,可以得到第二个 "<td><p>bb</p></td>".
    2.2 反向引用 \1, \2...
    表达式在匹配时,表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来.在获取匹配结果的时候,小括号包含的表达式所匹配到的字符串可以单独获取.这一点,在前面的举例中,已经多次展示了.在实际应用场合中,当用某种边界来查找,而所要获取的内容又不包含边界时,必须使用小括号来指定所要的范围.比如前面的 "<td>(.*?)</td>".
    其实,"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用,在匹配过程中也可以使用.表达式后边的部分,可以引用前面 "括号内的子匹配已经匹配到的字符串".引用方法是 "\" 加上一个数字."\1" 引用第1对括号内匹配到的字符串,"\2" 引用第2对括号内匹配到的字符串hh以此类推,如果一对括号内包含另一对括号,则外层的括号先排序号.换句话说,哪一对的左括号 "(" 在前,那这一对就先排序号.
    举例如下:
    举例1:表达式 1)" 在匹配 " 'Hello', "World" " 时,匹配结果是:成功;匹配到的内容是:" 'Hello' ".再次匹配下一个时,可以匹配到 " "World" ".
    举例2:表达式 "(\w)\1{4,}" 在匹配 "aa bbbb abcdefg ccccc 111121111 999999999" 时,匹配结果是:成功;匹配到的内容是 "ccccc".再次匹配下一个时,将得到 999999999.这个表达式要求 "\w" 范围的字符至少重复5次,注意与 "\w{5,}" 之间的区别.
    举例3:表达式 "<(\w+)\s*(\w+4)?\s*1>" 在匹配 "<td id='td1' style="bgcolor:white"></td>" 时,匹配结果是成功.如果 "<td>" 与"</td>" 不配对,则会匹配失败;如果改成其他配对,也可以匹配成功.
    2.3 预搜索,不匹配;反向预搜索,不匹配
    前面的章节中,我讲到了几个代表抽象意义的特殊符号:b".它们都有一个共同点,那就是:它们本身不匹配任何字符,只是对 "字符串的两头" 或者 "字符之间的缝隙" 附加了一个条件.理解到这个概念以后,本节将继续介绍另外一种对 "两头" 或者 "缝隙" 附加条件的,更加灵活的表示方法.
    正向预搜索:"(?=xxxxx)","(?!xxxxx)"
    格式:"(?=xxxxx)",在被匹配的字符串中,它对所处的 "缝隙" 或者 "两头" 附加的条件是:所在缝隙的右侧,必须能够匹配上 xxxxx 这部分的表达式.因为它只是在此作为这个缝隙上附加的条件,所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符.这就类似 "\b",本身不匹配任何字符."\b" 只是将所在缝隙之前、之后的字符取来进行了一下判断,不会影响后边的表达式来真正的匹配.
    举例1:表达式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT, Windows 2000" 时,将只匹配 "Windows NT" 中的 "Windows ",其他的 "Windows " 字样则不被匹配.
    举例2:表达式 "(\w)((?=\1\1\1)(\1))+" 在匹配字符串 "aaa ffffff 999999999" 时,将可以匹配6个"f"的前4个,可以匹配9个"9"的前7个.这个表达式可以读解成:重复4次以上的字母数字,则匹配其剩下最后2位之前的部分.当然,这个表达式可以不这样写,在此的目的是作为演示之用.
    格式:"(?!xxxxx)",所在缝隙的右侧,必须不能匹配 xxxxx 这部分表达式.
    举例3:表达式 "((?!\bstop\b).)+" 在匹配 "fdjka ljfdl stop fjdsla fdj" 时,将从头一直匹配到 "stop" 之前的位置,如果字符串中没有 "stop",则匹配整个字符串.
    举例4:表达式 "do(?!\w)" 在匹配字符串 "done, do, dog" 时,只能匹配 "do".在本条举例中,"do" 后边使用 "(?!\w)" 和使用 "\b" 效果是一样的.
    反向预搜索:"(?<=xxxxx)","(?<!xxxxx)"
    这两种格式的概念和正向预搜索是类似的,反向预搜索要求的条件是:所在缝隙的 "左侧",两种格式分别要求必须能够匹配和必须不能够匹配指定表达式,而不是去判断右侧.与 "正向预搜索" 一样的是:它们都是对所在缝隙的一种附加条件,本身都不匹配任何字符.
    举例5:表达式 "(?<=\d{4})\d+(?=\d{4})" 在匹配 "1234567890123456" 时,将匹配除了前4个数字和后4个数字之外的中间8个数字.由于 JScript.RegExp 不支持反向预搜索,因此,本条举例不能够进行演示.很多其他的引擎可以支持反向预搜索,比如:Java 1.4 以上的 java.util.regex 包,.NET 中System.Text.RegularExpressions 命名空间,以及本站推荐的最简单易用的 DEELX 正则引擎.
    3. 其他通用规则
    还有一些在各个正则表达式引擎之间比较通用的规则,在前面的讲解过程中没有提到.
    3.1 表达式中,可以使用 "\xXX" 和"\uXXXX" 表示一个字符("X" 表示一个十六进制数)
    形式
    字符范围
    \xXX
    编号在 0 ~ 255 范围的字符,比如:空格可以使用 "\x20" 表示
    \uXXXX
    任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示,比如:"\u4E2D"
    3.2 在表达式 "\s","\d","\w","\b" 表示特殊意义的同时,对应的大写字母表示相反的意义
    表达式
    可匹配
    \S
    匹配所有非空白字符("\s" 可匹配各个空白字符)
    \D
    匹配所有的非数字字符
    \W
    匹配所有的字母、数字、下划线以外的字符
    \B
    匹配非单词边界,即左右两边都是 "\w" 范围或者左右两边都不是 "\w" 范围时的字符缝隙
    3.3 在表达式中有特殊意义,需要添加 "\" 才能匹配该字符本身的字符汇总
    字符
    说明
    ^
    匹配输入字符串的开始位置.要匹配 "^" 字符本身,请使用 "\^"
    $
    匹配输入字符串的结尾位置.要匹配 "$" 字符本身,请使用 "\$"
    ( )
    标记一个子表达式的开始和结束位置.要匹配小括号,请使用 "\(" 和"\)"
    [ ]
    用来自定义能够匹配 '多种字符' 的表达式.要匹配中括号,请使用 "\[" 和"\]"
    { }
    修饰匹配次数的符号.要匹配大括号,请使用 "\{" 和"\}"
    .
    匹配除了换行符(\n)以外的任意一个字符.要匹配小数点本身,请使用 "\."
    ?
    修饰匹配次数为 0 次或 1 次.要匹配 "?" 字符本身,请使用 "\?"
    +
    修饰匹配次数为至少 1 次.要匹配 "+" 字符本身,请使用 "\+"
    *
    修饰匹配次数为 0 次或任意次.要匹配 "*" 字符本身,请使用 "\*"
    |
    左右两边表达式之间 "或" 关系.匹配 "|" 本身,请使用 "\|"
    3.4 括号 "( )" 内的子表达式,如果希望匹配结果不进行记录供以后使用,可以使用 "(?:xxxxx)" 格式
    举例1:表达式 "(?:(\w)\1)+" 匹配 "a bbccdd efg" 时,结果是 "bbccdd".括号 "(?:)" 范围的匹配结果不进行记录,因此 "(\w)" 使用 "\1" 来引用.
    3.5 常用的表达式属性设置简介:Ignorecase,Singleline,Multiline,Global
    表达式属性
    说明
    Ignorecase
    默认情况下,表达式中的字母是要区分大小写的.配置为 Ignorecase 可使匹配时不区分大小写.有的表达式引擎,把 "大小写" 概念延伸至 UNICODE 范围的大小写.
    Singleline
    默认情况下,小数点 "." 匹配除了换行符(\n)以外的字符.配置为 Singleline 可使小数点可匹配包括换行符在内的所有字符.
    Multiline
    默认情况下,表达式 "^" 和"$" 只匹配字符串的开始 ① 和结尾 ④ 位置.如:
    ①xxxxxxxxx②\n
    ③xxxxxxxxx④
    配置为 Multiline 可以使 "^" 匹配 ① 外,还可以匹配换行符之后,下一行开始前 ③ 的位置,使"$" 匹配 ④ 外,还可以匹配换行符之前,一行结束 ② 的位置.
    Global
    主要在将表达式用来替换时起作用,配置为 Global 表示替换所有的匹配.
    4. 其他提示
    4.1 如果想要了解高级的正则引擎还支持那些复杂的正则语法,可参见本站 DEELX 正则引擎的说明文档.
    4.2 如果要要求表达式所匹配的内容是整个字符串,而不是从字符串中找一部分,那么可以在表达式的首尾使用 "^" 和"$",比如:"^\d+$" 要求整个字符串只有数字.
    4.3 如果要求匹配的内容是一个完整的单词,而不会是单词的一部分,那么在表达式首尾使用 "\b",比如:使用 "\b(if|while|else|void|inthh)\b" 来匹配程序中的关键字.
    4.4 表达式不要匹配空字符串.否则会一直得到匹配成功,而结果什么都没有匹配到.比如:准备写一个匹配 "123"、"123."、"123.5"、".5" 这几种形式的表达式时,整数、小数点、小数数字都可以省略,但是不要将表达式写成:"\d*\.?\d*",因为如果什么都没有,这个表达式也可以匹配成功.更好的写法是:"\d+\.?\d*|\.\d+".
    4.5 能匹配空字符串的子匹配不要循环无限次.如果括号内的子表达式中的每一部分都可以匹配 0 次,而这个括号整体又可以匹配无限次,那么情况可能比上一条所说的更严重,匹配过程中可能死循环.虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了,比如 .NET 的正则表达式,但是我们仍然应该尽量避免出现这种情况.如果我们在写表达式时遇到了死循环,也可以从这一点入手,查找一下是否是本条所说的原因.
    4.6 合理选择贪婪模式与非贪婪模式,参见话题讨论.
    4.7 或"|" 的左右两边,对某个字符最好只有一边可以匹配,这样,不会因为 "|" 两边的表达式因为交换位置而有所不同.

    转载于:https://www.cnblogs.com/521taobao/archive/2012/03/17/2402435.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,739
精华内容 9,895
关键字:

java正则表达式入门

java 订阅