《编程思想》正则表达式学习笔记

• String类自带一个正则表达式工具 — split()方法,其功能是"将字符串从正则表达式匹配的地方切开"

public class Splitting {
    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+");
        split("n\\W+");
    }
}

运行结果:

• String类还有一个正则表达式工具是替换可以只替换正则表达式第一个匹配的字符串，或是替换所有匹配的地方

public class Replacing {
    static String s = Splitting.knights;
    public static void main(String[] args) {
        print(s.replaceFirst("f\\w+", "located"));
        print(s.replaceAll("shrubbery | tree | herring", "banana"));
    }
}

• 创建正则表达式：
  字符类：

.	任意字符
[abc]	包含 a、b、和 c 的任何字符
[^abc]	除了 a、b、c 以外的任意字符
[a-zA-Z]	从 a 到 z 或 A 到 Z 的任何字符
[acb[huj]]	任意a、b、c、h、i、j 的字符
a-z&&[hij]	任意 h、i 或 j（取交集）
\s	空白符（空格、tab、换行、换页、回车
\S	非空白符[^\s]
\d	数字0-9
\D	非数字
\w	词字符[a-zA-Z0-9]
\W	非词字符

边界匹配符：

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

量词：正则表达式中的量词是用来指定匹配中某些组或字符允许出现的次数
有以下三种类型：

• 贪婪型：量词总是贪婪的，除非有其他的选项被设置。贪婪表达式会为所有可能的模式发现尽可能多的匹配。导致此问题的一个典型理由就是假定我们的模式仅能匹配第一个可能的字符组，如果它是贪婪的，那么它就会继续往下匹配
• 勉强型：用问好来指定，这个量词匹配满足模式所需的最少字符数。因此也称为懒做的、最少匹配的。
• 占有型：目前，这种类型的量词只有在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次

• Pattern和Matcher
  一般来说，比起功能有限的String类，我们更愿意用构造功能强大的正则表达式对象。只需导入java.util.regex包，然后用static Pattern.compile()对象来编译正则表达式。它会根据想要检索的字符串传入Pattern对象的matcher()方法。接着产生一个matcher对象，它有很多功能可用

1.Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式

2.Pattern.matcher(CharSequence input)：Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例.
Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持

Mathcer.start（）：返回匹配到的子字符串在字符串中的索引位置
Mathcer.end（）：返回匹配到的子字符串的最后一个字符在字符串中的索引位置
Mathcer.group（）：返回匹配到的子字符串
Matcher.find() :查找多个匹配
Matcher.split() ：将输入字符串断开成字符串对象数组

下面的实例可以用来测试正则表达式，看看他们能否匹配一个输入字符串

public class TestRegularExpression {
    // { Args: abcabcabcdefabc "abc+" "(abc)+" "(abc){2,}" }
    public static void main(String[] args) {
            System.out.println("Input: \"" + args[0] + "\"");

            for (String arg : args) {
                System.out.println("Regular expression: \"" + arg + "\"");
                Pattern pattern = Pattern.compile(arg);
                Matcher matcher = pattern.matcher(args[0]);
                while (matcher.find()) {
                    System.out.println("Match \"" + matcher.group() + "\" at positions" +
                            matcher.start() + "-" + (matcher.end() - 1));
                }
            }
    }
}

输出：

Input: "abcabcabcdefabc"
Regular expression: "abcabcabcdefabc"
Match "abcabcabcdefabc" at positions0-14
Regular expression: "abc+"
Match "abc" at positions0-2
Match "abc" at positions3-5
Match "abc" at positions6-8
Match "abc" at positions12-14
Regular expression: "(abc)+"
Match "abcabcabc" at positions0-8
Match "abc" at positions12-14
Regular expression: "(abc){2,}"
Match "abcabcabc" at positions0-8

Pattern对象表示编译后的正则表达式。从这个例子中可以看到，我们使用已编译的Pattern对象上的matcher（）方法，加上一个输入字符串，从而共同构造了一个Matcher对象。同时，Pattern类还提供了static方法，该方法可以用来检测regex是否匹配整个CharSequence类型的input参数。编译后的Pattern对象还提供了split（）方法，并传入一个字符串参数，可以得到Matcher（）对象。使用Matcher（）上的方法，能够判断各种不同类型的匹配是否成功

• 正则表达式的替换功能
  String类的功能：public String replaceAll(String regex,String replacement)