我爱学Java之正则表达式

在程序开发过程中，难免会遇到需要匹配、查找、替换、判断字符串的情况发生，而这些情况有时又比较复杂，如果用纯编码方式解决，往往会浪费程序员的时间及精力，而正则表达式善于处理文本，对匹配、搜索和替换等操作都有意想不到的作用，因此，学习及使用正则表达式，便成了解决这一矛盾的主要手段。

1.匹配单个字符：”.”，如需匹配文本中的”.”，则需要对字符进行转义即”.”

Pattern pattern = Pattern.compile("J.va");
        String test = "123Java456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回Java

2.匹配一组字符：”[]”，如需匹配文本中的”[]”，需要对其进行转义
(1).匹配多个字符中的某一个：

Pattern pattern = Pattern.compile("J[aA]va");
        String test = "123Java456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回Java

(2).利用字符集合区间：

[A-Z]，匹配从A到Z的所有大写字母
[a-z]，匹配从a到z的所有小写字母
[0-9]，匹配从0-9所有数字
[a-z0-9]，匹配0-9和a-z的所有字母数字
[a|b|c], 包含a,b,c的任意字符
[a-z&&[hij]], 任意h，i，j（&&交集）
……

Pattern pattern = Pattern.compile("[0-9]J[a-z]va");
        String test = "123Java456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回3Java

(3).取非匹配

[^A-Z]，匹配除从A到Z之外的
[^a-z]，匹配除从a到z之外的
[^0-9]，匹配除从0-9之外的
[^a-z0-9]，匹配除0-9和a-z之外的

Pattern pattern = Pattern.compile("[^a-z]J[^0-9]va");
        String test = "123Java456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回3Java

3.匹配空白字符：

Pattern pattern = Pattern.compile("[^a-z]J[^0-9]va\r\n[0-9]");
        String test = "123Java\r\n456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回3Java 回车换行4

4.匹配特定字符类别:

\d 任何一个数字字符 <==> [0-9]
\D 任何一个非数字字符 <==> [^0-9]
\w 任何一个字母数字字符(大小写均可)或下划线 <==>[a-zA-Z0-9_]
\W 任何一个非字母数字字符或下划线 <==>[^a-zA-Z0-9_]
\s 任何一个空白字符 <==>[\f\n\r\t\v](换页，换行，回车，Tab，空格)
\S 任何一个非空白字符 <==? [^\f\n\r\t\v]

public static void main(String[] args){
        Pattern pattern = Pattern.compile("\\D\\wva\\s\\s\\d");
        String test = "123Java\r\n456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回Java 回车换行4

    }

5.重复匹配：

(1).有多少个匹配

“+” 匹配一个或多个字符
“*” 匹配零个或多个字符
“?” 匹配零个或一个字符

Pattern pattern = Pattern.compile("\\d*4?\\w+");
        String test = "123Java456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回123Java456

(2).匹配的重复次数

{n} 必须重复n次
{m，n} 最少重复m次，最多重复n次
{m，} 至少重复m次

Pattern pattern = Pattern.compile("\\D{2,4}\\d{3}\\w{1,}");
        String test = "Java123Java456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回Java123Java456

(3).懒惰型匹配：尽可能匹配少的字符避免过度匹配

在* 或 + 或 {n，} 后加 ？

Pattern pattern = Pattern.compile("<[Hh]1>.*?</[Hh]1>");
        String test = "<h1>Java</h1><h1>Java</h1>";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回<h1>Java</h1>,如不用懒惰模式，则返回<h1>Java</h1><h1>Java</h1>

6.位置匹配：

(1).单词边界：

\b 用来匹配一个单词的开始或结尾

Pattern pattern = Pattern.compile("\\bJava\\b");
        Pattern pattern = Pattern.compile("\\bJava\\b");
        String test = "Hello Java JavaHello Hello";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回Java

\B 不限定边界

Pattern pattern = Pattern.compile("\\BJava\\B");
        String test = "HelloJavaHello Hello";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回Java

(2).字符串边界

^匹配一个字符串的开头：

Pattern pattern = Pattern.compile("^\\d+\\w*");
        String test = "123Java";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回123Java

$匹配一个字符串的末尾：

Pattern pattern = Pattern.compile("\\d*\\w{1,3}a$");
        String test = "123Java";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回123Java

(3) 分行匹配：

(?m) : 必须出现在整个模式的最前面

Pattern pattern = Pattern.compile("(?m)^\\d.*$");
        String test = "123Java\r\n456";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回123Java

7.子表达式：是更大的表达式的一部分，把一个表达式划分为一系列子表达式的目的是为了把那些子表达式当做一个独立元素来使用，子表达式需要用()括起来

Pattern pattern = Pattern.compile("(1|2)\\w*");// "|"运算符会把符号右边当做整个一部分，所有需要用到子表达式以独立开
        String test = "1Java";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回1Java

8.回溯引用：指的是模式的后半部分引用在是前半部分中定义的子表达式

Pattern pattern = Pattern.compile("<[Hh]([1-6])>.*</[Hh]\\1>");//\1 代表代表第一个表达式，以此类推，如有第二个子表达式 则\2代表第二个子表达...
        String test = "<h1>Java</h1>";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回<h1>Java</h1>

9.前后查找

(1)向前查找：(?=)

Pattern pattern = Pattern.compile(".+(?=:)");
        String test = "hello:Java";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回hello

(2)向后查找：(?<=)

Pattern pattern = Pattern.compile("(?<=:).+");
        String test = "hello:Java";
        Matcher matcher = pattern.matcher(test);
        matcher.find();
        System.out.println(matcher.group());//返回Java