Java 正则表达式

基础
    一般来说，正则表达式就是以某种方式进行描述字符串，因此可以说成如果字符串种含有表达式中含有的东西，那么这个字符串就是该正则表达式要找的东西。比如要找一个数字，可能包含一个负号，那么就可以用“-？”来表示。
在Java语言中，“\”表示插入一个正则表达式反斜杠，所以其后的字符具有特殊的意义，比如要表示一个数字，用“\d”来表示。比如要插入一个普通的反斜杠，则用“\\”表示。要表示一个或者多个之前的表达式，用“+”表示。
使用正则表达式最简单的引用就是使用String类的内建功能（匹配）。比如：

public class IntegerMatch{
    public static void main(String[] args){
        System.out.println("-1234".matches("-?\\d+"));
        System.out.println("1234".matches("-?\\d+"));
        System.out.println("+1234".matches("-?\\d+"));
        System.out.println("+5678".matches("(-|\\+)?\\d+"));
        //在正则表达式中，括号有着将表达式分组的功能，“|”用来表示或。
    }
}

//输出结果：
//true
//true
//fasle
//true

String类还有一个非常有用的表达式工具：split()方法。将字符串从表达式匹配的地方分割。

import java.util.Arrays;

public class Main{
    public static String knights = 
            "Then, when you have found the shrubbery, you must"
            + " cut down the mightiest tree in the forest..."
            + " with... a herring!";
    public static void split(String regex){
        System.out.println(
                Arrays.toString(knights.split(regex)));
    }
    public static void main(String[] args) {
        split(" ");         //不包含任何特殊的字符，按空格划分。
        split("\\W+");      //\W表示非单词字符，结果将标点删除了。
        split("n\\W+");     //字母n后边跟着一个或者多个字符。
    }
}

/*输出结果
 *[Then,, when, you, have, found, the, shrubbery,, you, must, cut, down, the, mightiest, tree, in, the, forest..., with..., a, herring!]
 *[Then, when, you, have, found, the, shrubbery, you, must, cut, down, the, mightiest, tree, in, the, forest, with, a, herring]
 *[The, whe, you have found the shrubbery, you must cut dow, the mightiest tree i, the forest... with... a herring!]
*/

String类还有一个正则表达式的工具是“替换”，可以替换第一个匹配的子串或者所有的匹配的地方。

public class Main{
    public static void main(String[] args) {
        String str = "I am five!";
        System.out.println(str.replaceFirst("f\\w+", "six"));
    }
}//结果：I am six!

创建正则表达式

//常用的正则表达式

//字符
B               指定字符B
\xhh            16进制值为oxhh的字符
\xhhhh          16进制表示为oxhhhh的Unicode字符。
\t              制表符
\r              回车
\f              翻页
\e              转义

//字符类
.               任意字符
[abc]           包含a,b和c的任何字符（等同于a|b|c）
[^abc]          除了a,b,c之外的任何字符（否定）
[a-zA-Z]        a到z或者A-Z的任何字符（范围）
[abc[hij]]      任意a,b,c,h,i,j字符（合并）
\s              空白符（空格，Tab，换行，换页和回车）
\S              非空白符（^\s）
\d              数字（[0-9]）
\D              非数字（[^0-9]）
\w              词字符（[a-zA-Z0-9]）
\W              非词字符（[^\w]）

//逻辑操作符
XY              Y跟在X后边
X|Y             X或者Y
(X)             捕获组，可以在表达式中用\i引用第i个捕获组

//边界匹配符
^               一行的起始
$              一行的结束
\b              词的边界
\B              非词的边界
\G              前一个匹配的结束

量词
量词是描述了一个模式吸收文本的方式：
（1） 贪婪型：量词总是贪婪的，贪婪表达式会尽可能多的匹配。
（2） 勉强型：用问号来指定，这个量词匹配满足模式所需的最少字符。
（3） 占有型：只有Java中才有，占有型表达式可以防止“回溯”，常常用于防止正则表达式失控。

//      贪婪型            勉强型           占有型            如何匹配
//        X?              X??             X?+           一个或零个X
//        X*              X*?             X*+           零个或者多个X
//        X+              X+?             X++           一个或者多个X
//        X{n}            X{n}?           X{n}+         恰好n次X
//        X{n,}           X{n,}?          X{n,}+        至少n次X
//        X{n,m}          X{n,m}?         X{n,m}+       X至少n次，不超过m次

//例如：匹配一个或者多个abc字符串：
        (abc)+
//如果输入abcabcabc则有3个匹配。      

Pattern和Matcher
Pattern类和Mather类在java.util.regex中，使用静态方法Pattern.compile(regex);编译正则表达式，生成一个Pattern对象。将想要检索的字符串传入Pattren对象的matcher()方法，返回一个Matcher对象，可以用Matcher对象的各种方法进行操作，比如：find()，replaceAll()等方法。

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

public class Main{
    public static void main(String[] args) {
        String str = "I am five!";
        String regex = "(fi)+\\w*";
        Pattern p = Pattern.compile(regex);
        Matcher matcher = p.matcher(str);
        while (matcher.find()) {
            System.out.println("匹配的字符串：" + matcher.group());
            System.out.println("在字符串中位置：" + matcher.start() + "~"
                    + (matcher.end()-1));
        }
    }
}/*结果：匹配的字符串：five
        在字符串中位置：5~8*/

Pattern标记
Pattern的compile()方法还有另外一个版本，接收一个标记，以调整匹配的行为。方法：

Pattern，compile(String regex,int flag);

flag常量：
1. Pattren.CANON_EQ：指定此标志后，当且仅当其完整规范分解匹配时，两个字符才可视为匹配。例如，当指定此标志时，表达式 “a\u030A” 将与字符串 “\u00E5” 匹配。默认情况下，匹配不考虑采用规范等价。
2. Pattren.CASE_INSENSITIVE（?i）:启用不区分大小写的匹配。 默认情况下，不区分大小写的匹配假定仅匹配 US-ASCII 字符集中的字符。可以通过指定 UNICODE_CASE 标志连同此标志来启用 Unicode 感知的、不区分大小写的匹配。
3. Pattern.COMMENTS(?x):此模式将忽略空白和在结束行之前以 # 开头的嵌入式注释
4. Pattern.DOTALL(?s):在 dotall 模式中，表达式 . 可以匹配任何字符，包括行结束符。默认情况下，此表达式不匹配行结束符。
5. Pattren.MULTILINE(?m):在多行模式中，表达式 ^ 和 $ 仅分别在行结束符前后匹配，或者在输入序列的结尾处匹配。默认情况下，这些表达式仅在整个输入序列的开头和结尾处匹配。
6. Pattren.CASE_INSENSITIVE(?u):指定此标志后，由 CASE_INSENSITIVE 标志启用时，不区分大小写的匹配将以符合 Unicode Standard 的方式完成。默认情况下，不区分大小写的匹配假定仅匹配 US-ASCII 字符集中的字符。
7. Pattren.UNIX_LINES(?d):在此模式中，.、^ 和 $ 的行为中仅识别 ‘\n’ 行结束符。
注：这些常量可以直接插入在正则表达式中使用，即常量后括号里的内容，只需要将括号里的字符串插入在想起作用的地方即可。可以通过“|”组合多个标记的功能。

正则表达式除了应用在静态的字符串中，还可以应用在文件中，可以输出匹配的部分和匹配部分在文件中的位置