java中正则表达式的使用

2023-05-05 17:27:17 浏览数 (1)

java中正则表达式的使用

相关API类的使用示例

java中正则表达式匹配,主要使用api中的个类:PatternMatcherPatternSyntaxException

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

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

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

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

代码语言:javascript复制
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
    }
}
正则表达式
字符类
代码语言:javascript复制
[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] 
预定义字符类
代码语言:javascript复制
. 任意字符
d 任意一个数字,等同于 [0-9] 
D 任意一个非数字字符,等同于 [^0-9] 
h 任意一个水平空白字符,等同于 [ txA0u1680u180eu2000-u200au202fu205fu3000] 
H 任意一个非水平空白字符,等同于 [^h] 
s 任意一个空白字符,等同于 [ tnx0Bfr] 
S 任意一个非空白字符,等同于 [^s] 
v 任意一个垂直空白字符,等同于 [nx0Bfrx85u2028u2029]  
V 任意一个非垂直空白字符,等同于 [^v] 
w 任意一个单词字符,等同于 [a-zA-Z_0-9] 
W 任意一个非单词字符,等同于 [^w] 
边界匹配类
代码语言:javascript复制
^ 开始字符,后面接的第一个字符表示是 第一个字符。 
$ 结尾字符,前面的那个字符表示是 最后一个字符。 
b 单词字符边界
B 非单词字符边界 
A 输入的开始 
G 前一个匹配的结尾 
贪心匹配
代码语言:javascript复制
X? X, 0个或一个
X* X, 零个或多个
X  X, 一个或多个
X{n} X, n个
X{n,} X, 至少n个 
X{n,m} X, 至少n个,最多m个 
逻辑操作
代码语言:javascript复制
XY X后面跟Y 
X|Y X或Y
(X) X, 作为一个组

0 人点赞