正则表达式

package cn.zjx.demo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
    /**正则表达式语法*/
    
    /**1.元字符的语法, Unix中的vi编辑器、Perl脚本语言等。此外，现在流行的开发语言比如C#、VB、Java等等也都提供了对正则表达式的直接支持，甚至在像JavaScript这种脚本语言中也能发现对正则表达式的支持*/
    
    // . 匹配任何单个字符。例如正则表达式"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"但是"o"(第一个匹配不上就整个匹配不上)或"zoz"和"zozo" "zzz" "zooz"就不可以；正则表达式".*"意味着能够匹配任意字符串。
    // / 转义符，用来将元字符当作普通的字符来进行匹配。例如正则表达式/$被用来匹配美元符号，而不是行尾；正则表达式/.用来匹配点字符，而不是任何字符的通配符。
    // []匹配括号中的任何一个字符。例如正则表达式"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"。
    
    /**Java中的正则表达式API, 从JDK1.4开始提供了支持正则表达式API，它们位于java.util.regex包中，由于已经有了标准API*/
    /**java.util.regex中定义了一些表达式的简写*/
    
    // /t：制表符，等同于/u0009
    // /n：换行符，等同于/u000A
    // /d：代表一个数字，等同于[0-9]
    // /D：代表非数字，等同于[^0-9]
    // /s：代表换行符、Tab制表符等空白字符
    // /S：代表非空白字符
    // /w：字母字符，等同于[a-zA-Z_0-9]
    // /W：非字母字符，等同于[^/w] 
    /*****************************************************************************************************************/
    
    /**java.util.regex的使用*/
    /*
     java.util.regex中包括了两个类：Pattern和Matcher,一个Pattern对象就是一个正则表达式经编译后的表现模式，也就是前边所说的"模式编译器"；
     一个Matcher对象是一个状态机器，它根据Pattern对象做为匹配模式对字符串展开匹配检查，也就是前边说的"模式匹配器"。
     Pattern类有如下重要的方法：
    (1)public static Pattern compile(String regex)：将给定的正则表达式编译并返回编译后的Pattern对象。
    (2)public static Pattern compile(String regex, int flags)：将给定的正则表达式编译并返回编译后的Pattern对象，flag参数表示匹配时的选项，可选的flag参数包括：CASE_INSENSITIVE,COMMENTS，MULTILINE,DOTALL,UNICODE_CASE，CANON_EQ。 
    (3)public int flags()：返回flag选项参数.
    (4)public static boolean matches(String regex, CharSequence input)：直接判断字符序列input是否匹配正则表达式regex。前面曾经提到当需要使用一个正则表达式进行多次匹配的时候，对正则表达式进行预编译能够加快运行速度，但是如果这个匹配只进行一次的话，就可以调用这个matches方法直接判断是否匹配，这样就方便多了。这段代码内部的实现代码就是：Pattern.compile(regex).matcher(input).matches()；
    Matcher 类有如下重要的方法：
    (1)public boolean matches()：生成一个给定命名的Matcher对象 
    (2)public String pattern()：返回该Pattern对象所编译的正则表达式。 
    (3)public String[] split(CharSequence input)
    将目标字符序列input按照Pattern里所包含的正则表达式为模式进行分割。 
    (4)public String[] split(CharSequence input, int limit) 将目标字符序列input按照Pattern里所包含的正则表达式为模式进行分割，参数limit作用是指定要分割的段数，如将limi设为2，那么目标字符序列将根据正则表达式分为割为两段。
    (5)public String group(int group) ：得到匹配结果中提取的第group个分组的值。此方法在字符串提取中经常用到。
    (6)public String replaceAll(String replacement)：用指定的字符串替换匹配的子串。
     */
    
    public static void main(String[] args) {
        String input1 = "booooooog";
        String regex1 = "b*g";
        Pattern pattern1 = Pattern.compile(regex1);
        Matcher matcher1 = pattern1.matcher(input1);
        boolean b1 = matcher1.matches();
        System.out.println(b1);//false
        
        String input2 = "bbbbbbbbg";
        String regex2 = "b*g";
        Pattern pattern2 = Pattern.compile(regex2);
        Matcher matcher2 = pattern2.matcher(input2);
        boolean b2 = matcher2.matches();
        System.out.println(b2);//true
        
        String input3 = "booooooog";
        String regex3 = "bo*g";
        Pattern pattern3 = Pattern.compile(regex3);
        Matcher matcher3 = pattern3.matcher(input3);
        boolean b3 = matcher3.matches();
        System.out.println(b3);//true
        
        String input4 = "bog";
        String regex4 = "bo*g";
        Pattern pattern4 = Pattern.compile(regex4);
        Matcher matcher4 = pattern4.matcher(input4);
        boolean b4 = matcher4.matches();
        System.out.println(b4);//true
        
        String input5 = "boo";
        String regex5 = "bo*g";
        Pattern pattern5 = Pattern.compile(regex5);
        Matcher matcher5 = pattern5.matcher(input5);
        boolean b5 = matcher5.matches();
        System.out.println(b5);//false
        
        String input6 = "boog";
        String regex6 = "bo*g";
        Pattern pattern6 = Pattern.compile(regex6);
        Matcher matcher6 = pattern6.matcher(input6);
        boolean b6 = matcher6.matches();
        System.out.println(b6);//true
        
        String input7 = "b";
        String regex7 = "bo*";
        Pattern pattern7 = Pattern.compile(regex7);
        Matcher matcher7 = pattern7.matcher(input7);
        boolean b7 = matcher7.matches();
        System.out.println(b7);//true
        
        String input8 = "bo";
        String regex8 = "bo*";
        Pattern pattern8 = Pattern.compile(regex8);
        Matcher matcher8 = pattern8.matcher(input8);
        boolean b8 = matcher8.matches();
        System.out.println(b8);//true
    }
}

下面看一下简单的正则表达式的例子。

【例1-1】 简单的字符匹配

代码 1.4 简单的正则表达式字符匹配

Pattern p = Pattern.compile("b*g");

Matcher m = p.matcher("bbbbbbg");

boolean b = m.matches();

System.out.println(b);

运行结果为：

true

因为“b*g”匹配的字符0至多个“b”后面有一个“g”，所以“bbbbbbg”匹配。

这里采用简化形式，并匹配另外一个字符串：

boolean b = Pattern.matches("b*g","bug");

System.out.println(b);

运行结果为：

false

正则表达式不仅能进行字符串的匹配，还能进行字符串的提取、替换。下面就演示一个字符串提取的例子：

【例1-2】从文件路径中提取出文件名(包含后缀)

比如从“c:/dir1/dir2/name.txt”中提取出“name.txt”。

代码 1.5 字符串提取

String regEx = ".+/(.+)$";

String str = "c:/dir1/dir2/name.txt";

Pattern p = Pattern.compile(regEx);

Matcher m = p.matcher(str);

if (!m.find())

{

    System.out.println("文件路径格式错误!");

    return;

}

System.out.println(m.group(1));

运行结果：name.txt

正则表达式“.+/(.+)$”的含义就是：被匹配的字符串以任意 字符序列开始，后边紧跟着字符“/”，最后以任意字符序列结尾，“()”代表分组操作，这里就是把文件名做为分组，匹配完毕我们就可以通过Matcher 类的group方法取到我们所定义的分组了。需要注意的这里的分组的索引值是从1开始的，所以取第一个分组的方法是m.group(1)而不是 m.group(0)。