旋涡JAVA笔记--正则表达式

（疯狂JAVA讲义）– 摘要
正则表达式是一个强大的字符串处理工具，可以对字符串进行 查找 提取
、分割、替换等操作。String类中也提供了诸如matches（）、replaceAll（）、replaceFirst（）、split（）等 Java还提供了Pattern和Matcher两个类来专门用于提供正则表达式支持。

正则表达式所支持的合法字符：

1. x (可表示任何合法字符)
2. \0mnn（8进制数0mnn所表示的字符）
3. \xhh(16进制0xhh所表示的字符)
4. \uhhhh（16进制值所表示的Unicode字符）
5. \t(制表符)
6. \n(换行符)
7. \r(回车符)
8. \f(换页符)
9. \a(报警)
10. \e(Escape符)

正则表达式的特殊字符：
注：要匹配如下的字符可加“\”

1. $ 匹配一行的结尾
2. ^ 匹配一行的开头
3. () 标记字表达式的开头和结尾
4. [] 确定中括号的开头和结尾位置
5. {} 标记前面字表达式的出现频度 eg：“\w{3}”
6. *字表达式出现0~+∞次
7. ？字表达是出现0~1次
8. +字表达是出现1~+∞次
9. .匹配除 \n 外单字符
10. \ 转义下一个字符通常在一个正则表达式中多次出现
11. | 两项之间任选一项=>or

预定义字符：

1. \d 匹配0~9之间的数字
2. \D 匹配非数字
3. \s 匹配所有空白字符 eg：\t \n \f \r
4. \S 匹配所有非空白字符
5. \w 匹配所有单词字符
6. \W 匹配所有非单词字符

Pattern Matcher类

Pattern是不可变类可供多个并发线程安全使用
Matcher类提供的常用方法如下：

1. find（） 返回目标字符串中是否包含与Pattern（模板）匹配的子串
2. group() 返回上一次与Pattern匹配的子串
3. start() 返回上一次与Pattern匹配的子串在目标字符串中的开始位置
4. end() 返回上一次与Pattern匹配的子串在目标字符串中的结束位置+1
5. lookingAt() 返回目标字符串前面部分与Pattern是否匹配
6. matches() 返回整个目标字符串与Pattern是否匹配
7. reset() 将现有的matcher对象应用于一个新的字符串序列

public class JavaTest {
    public static void main(String[] args) {
        String str = "我想购买一本《疯狂JAVA讲义》，尽快联系我13500006666，" +
                "范德萨发集合地少废话代课老师13611125565" +
                "范德萨发大水发的撒范德萨范德萨15899903312";
        Matcher m  = java.util.regex.Pattern.compile("((13\\d)|(15\\d))\\d{8}").matcher(str);
        while (m.find()){
            System.out.println(m.group());
        }
    }
}

*运行结果为：
13500006666
13611125565
15899903312*

public class StartEnd {
    public static void main(String[] args) {
        String regStr = "Java Is My Love";
        Matcher matcher = Pattern.compile("\\w+").matcher(regStr);
        while (matcher.find()) {
            System.out.println(matcher.group() +
                    "子串起始位置" + matcher.start() +
                    "子串结束位置" + matcher.end());
        }
    }
}

*运行结果：
Java子串起始位置0子串结束位置4
Is子串起始位置5子串结束位置7
My子串起始位置8子串结束位置10
Love子串起始位置11子串结束位置15*

*注：上段代码是对单词进行分割

public class StringReg {
    public static void main(String[] args) {
        String[] msgs = {
                "Java has regular expressions in 1.4",
                "regular expressions now expressing in java",
                "java represses oracular expressions"
        };
        for (String msg : msgs) {
            System.out.println(msg.replaceFirst("re\\w*", "哈哈：）"));
            System.out.println(Arrays.toString(msg.split(" ")) + "\n");
        }
    }
}

*运行结果：
[Java, has, regular, expressions, in, 1.4]

哈哈：） expressions now expressing in java
[regular, expressions, now, expressing, in, java]

java 哈哈：） oracular expressions
[java, represses, oracular, expressions]*

*注：Arrays 类中的静态方法 Arrays.toString（）

public class ReplaceTest {
    public static void main(String[] args) {
        String[] msgs = {
                "Java has regular expressions in 1.4",
                "regular expressions now expressing in java",
                "java represses oracular expressions"
        };
        Pattern p = Pattern.compile("re\\w*");
        Matcher matcher = null;
        for (String msg : msgs) {
            if (matcher == null){
                matcher = p.matcher(msg);
            }else{
                matcher.reset(msg);
            }
            System.out.println(matcher.replaceAll("哈哈:)"));
        }
    }
}

*运行结果：
Java has 哈哈:) exp哈哈:) in 1.4
哈哈:) exp哈哈:) now exp哈哈:) in java
java 哈哈:) oracular exp哈哈:)*

*注：此段代码是用来替换符合re开头的单词为–>[ 哈哈：） ]

    public static void main(String[] args) {
        String[] mails = {
                "kongyeeku@q63.com",
                "kongyeeku@gmile.com",
                "liguang@crazyit.org",
                "wawa@abc.com"
        };
        String mailRegEx = "\\w{3,20}@\\w+\\.(com|org|cn|net|gov)";
        Pattern mailPattern = Pattern.compile(mailRegEx);
        Matcher matcher = null;
        for (String mail : mails) {
            if (matcher == null) {
                matcher = mailPattern.matcher(mail);
            } else {
                matcher.reset(mail);
            }
            String result = mail + "\t" + (matcher.matches() ? "yes" : "no") + "\n一个有效的邮箱地址";
            System.out.println(matcher + "\t" + result);
        }
    }
}

*运行结果为：
java.util.regex.Matcher[pattern=\w{3,20}@\w+.(com|org|cn|net|gov) region=0,17 lastmatch=kongyeeku@q63.com] kongyeeku@q63.com yes
一个有效的邮箱地址
java.util.regex.Matcher[pattern=\w{3,20}@\w+.(com|org|cn|net|gov) region=0,19 lastmatch=kongyeeku@gmile.com] kongyeeku@gmile.com yes
一个有效的邮箱地址
java.util.regex.Matcher[pattern=\w{3,20}@\w+.(com|org|cn|net|gov) region=0,19 lastmatch=liguang@crazyit.org] liguang@crazyit.org yes
一个有效的邮箱地址
java.util.regex.Matcher[pattern=\w{3,20}@\w+.(com|org|cn|net|gov) region=0,12 lastmatch=wawa@abc.com] wawa@abc.com yes
一个有效的邮箱地址*

*注：Matcher的结果在控制台输出的是类似于
java.util.regex.Matcher[pattern=\w{3,20}@\w+.(com|org|cn|net|gov) region=0,17 lastmatch=kongyeeku@q63.com]这样的字符串