java中正则表达式的使用

java中正则表达式的使用

相关API类的使用示例

java中正则表达式匹配，主要使用api中的个类：Pattern、Matcher、PatternSyntaxException

Pattern 类的静态方法 compile(String regexp) 可以将给定的正则表达式编译成模式。

Matcher 类的实例可以通过已经编译好的模式的方法 matcher(String arg) 获取匹配器。

Matcher 类的 matches() 方法可以获取匹配结果。

Pattern 类的另一个静态方法可以一步匹配正则表达式：Pattern.matches(regexp, arg);，该方法得到的模式实例是不可变的，是多线程安全的。

package byron4j.javaRelationSkill.Regexp;

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

/**
 * java正则表达式API主要3各类：Pattern、Matcher、PatternSyntaxException
 * 
 * Pattern :  没有提供公有的构造器； 使用compile方法接受一个正则表达式的参数可以返回一个Pattern实例。
 * 
 * @author BYRON.Y.Y
 *
 */
public class RegexpDemo {
    public static void main(String[] args) {
        //String arg = “helloword”;//false
        //String arg = “123”;//false
        String arg = “13712345678”;
        String regexp = “[1-9]{11}”;

        //方式一：
        //step1： 编译正则表达式
        Pattern pattern = Pattern.compile(regexp);
        //step2： 创建一个匹配器（匹配正则表达式）
        Matcher matcher = pattern.matcher(arg);
        //step3： 获取匹配结果
        boolean result = matcher.matches();

        System.out.println(“正则匹配结果:” + result);                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

        //方式二：不允许重用已编译的模式。 此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。
        //等同于 setp1 + step2 + step3
        Pattern.matches(regexp, arg);

        matcher.find();

        /
        String 非a_z = “[^a-z]”;
        System.out.println(Pattern.matches(非a_z, “a”));//true
        System.out.println(Pattern.matches(非a_z, “A”));//false
    }
}

正则表达式

字符类

[abc] a, b, or c 的其中一个字符
[^abc] 任意一个除去 a, b, or c 的字符
[a-zA-Z] 任意一个a-z或者A-Z之间的一个字符 
[a-d[m-p]] 任意一个a-d或者m-p之间的一个字符等同于 [a-dm-p] 
[a-z&&[def]] d, e, or f任意一个字符
[a-z&&[^bc]] a-z中任意非b、c的一个字符，等同于 [ad-z] 
[a-z&&[^m-p]] a-z中任意非m-p中的字符，等同于 [a-lq-z] 

预定义字符类

. 任意字符
\d 任意一个数字，等同于 [0-9] 
\D 任意一个非数字字符，等同于 [^0-9] 
\h 任意一个水平空白字符，等同于 [ \t\xA0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000] 
\H 任意一个非水平空白字符，等同于 [^\h] 
\s 任意一个空白字符，等同于 [ \t\n\x0B\f\r] 
\S 任意一个非空白字符，等同于 [^\s] 
\v 任意一个垂直空白字符，等同于 [\n\x0B\f\r\x85\u2028\u2029]  
\V 任意一个非垂直空白字符，等同于 [^\v] 
\w 任意一个单词字符，等同于 [a-zA-Z_0-9] 
\W 任意一个非单词字符，等同于 [^\w] 

边界匹配类

^ 开始字符，后面接的第一个字符表示是 第一个字符。 
$ 结尾字符，前面的那个字符表示是 最后一个字符。 
\b 单词字符边界
\B 非单词字符边界 
\A 输入的开始 
\G 前一个匹配的结尾 

贪心匹配

X? X, 0个或一个
X* X, 零个或多个
X+ X, 一个或多个
X{n} X, n个
X{n,} X, 至少n个 
X{n,m} X, 至少n个，最多m个 

逻辑操作

XY X后面跟Y 
X|Y X或Y
(X) X, 作为一个组