java中正则表达式的使用

- 日理万妓 2022-05-31 14:21 232阅读 0赞

## 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, 作为一个组