Java魔法堂:深入正则表达式API

目录                              

一、前言

二、正则表达式的使用诉求

三、java.util.regex包

四、java.lang.String实例

五、最短路径实现诉求

六、Java支持的正则表达式功能语法

七、总结

八、参考

一、前言                             

  正则表达式作为文本处理的利器,早已成为各大语言的必要装备,但各语言对其的实现程度(功能语法支持程度)和API设计均有所差异,本篇将目光投向java原生类库中提供的正则表达式API—— java.util.regex包 和 java.lang.String实例方法 ,和所支持的功能语法上。

二、 正则表达式的使用诉求                    

  正则表达式一般用于处理如下诉求,本篇后续内容将以这些诉求为基础检验相关的原生API是否提供方便有效(code less,do more)的操作方式。

1. 匹配字符串:全字符串匹配、部分匹配(也就是包含关系)

  2. 替换字符串

3. 萃取字符串

4. 拆分字符串

三、 java.util.regex包

  从jdk1.5开始正则表达式相关API就集中存放在该包下,且为其他类中表达式相关方法提供基础处理能力。

  1.  java.util.regex.Pattern类 :模式类,用于对正则表达式进行编译。

 类方法:

/*
 * 对正则表达式进行编译,并返回Pattern实例
 * 入参flag作为表达式属性,启用多个表达式属性时,采用管道符(|)连接多个表达式属性。除了通过入参的方式设置表达式属性,还可以使用嵌入式标识来设置表达式属性,格式为:(?表达式属性1表达式属性2)正则表达式,示例——不区分大小写和全局匹配abcd:(?ig)abcd
 */
Pattern compile(String regex);
Pattern compile(String regex, int flag);

// 字符串完整匹配表达式的快捷方式,内部依然是
// Pattern p = Pattern.compile(regex);
// p.matcher(input).matches();
boolean matches(String regex, CharSequence input);

// 返回可以配置入参s的字面量模式。注意格式为\\Q表达式\\E。表达式中的元字符将当作普通字符处理
String quote(String s);

      表达式属性:

// 以\n作为换行符,内嵌为(?d)
Pattern.UNIX_LINES

// US-ASCII编码字符不区分大小写,内嵌为(?i)
Pattern.CASE_INSENSITIVE

// 忽略空格和注释(注释为以#开头直到出现换行符),内嵌为(?x)
Pattern.COMMENTS

// 启动多行模式,^和$匹配换行符或字符串起始位置。默认为单行模式,^和$仅匹配字符串起始位置。内嵌为(?m)
Pattern.MULTILINE

// 字面量模式,将元字符当作普通字符处理,没有内嵌方式,但可以通过"\\Q正则表达式\\E"的方式实现
Pattern.LITERAL

// 元字符.将匹配换行符。默认情况下,元字符.不匹配换行符。内嵌为(?s)
Pattern.DOTALL

// UNICODE编码字符不区分大小写,内嵌为(?u)
Pattern.UNICODE_CASE

// 当且仅当正则分解匹配时才配置成功。
Pattern.CANON_EQ

// 启用Unicode版本的预定义字符类和POSIX字符类,内嵌为(?U)
Pattern.UNICODE_CHARACTER_CLASS

       实例方法:

// 返回正则表达式
String pattern();

// 使用正则表达式匹配的字符串切割入参input
// 入参limit用于设置返回数组长度的最大值,设置为0时则不限制最大值。
String[] split(CharSequence input);
String[] split(CharSequence input, int limit);

// 获取匹配类
Matcher matcher(CharSequence input);

   2. java.util.regex.Matcher类 :匹配类,用于存储模式实例匹配某字符串后所产生的结果。

       静态方法:

// 将入参s中的\和$元字符转换为普通字符,并返回处理后的s字符串。
String quoteReplacement(String s)

      实例方法:

// 获取匹配子字符串的起始索引
int start();
// 获取匹配子字符串的结束索引
int end();

// 从字符串的end+1位置开始搜索下一个匹配的字符串
boolean find();
boolean find(int start);

// 通过分组索引获取分组内容,若入参group超出分组数量则抛异常
String group();
String group(int group);
// 通过分组名称获取分组内容,若没有相应的分组则返回null
String group(String name);

// 重置匹配实例内部的状态属性
Matacher reset();
// 重置匹配实例内部的状态属性,并重置被匹配的字符串
Matacher reset(CharSequence input);
// 重置模式实例,这导致group信息丢失,但注意:start等信息依旧保留不变。
Matcher usePattern(Pattern newPattern);

// 从字符串起始位开始将匹配成功的子字符串均用入参replacement替换掉
String replaceAll(String replacement);
// 从字符串起始位开始将第一个匹配成功的子字符串均用入参replacement替换掉
String replaceFirst(String replacement);
// 将从字符串起始位开始到最后一匹配的子字符串最后一个字符的位置的字符串复制到sb中,并用入参replacement替换sb中匹配的内容
String appendReplace(StringBuffer sb, String replacement);
// 将剩余的子字符串复制到sb中
String appendTail(StringBuffer sb);
// 示例: sb为one dog two dog
Matcher m = p.matcher("one cat two cats in the yard");
StringBuffer sb = new StringBuffer();
while (m.find()) {
  m.appendReplacement(sb, "dog");
}

// 字符串从头到尾匹配表达式
boolean matches();
// 从字符串起始位置开始匹配表达式,但不要字符串从头到尾匹配表达式
boolean lookingAt();

四、 java.lang.String实例

   实例方法:

String replaceAll(String replacement);
String replaceFirst(String replacement);
String[] split(String regex);
String[] split(String regex, int limit);
boolean matches(String regex)

五、最短路径实现诉求                          

final class RegExp{
    // 全字符串匹配
    public static boolean isMatch(String regex, String input){
        if (null == input) return false;
        return input.matches(regex);
    }
    
    // 包含子字符串
    public static boolean contains(String regex, String input){
        Pattern r = Pattern.compile(regex);
        return r.matcher(input).find();
    }

    // 实现indexOf
    public static int indexOf(String regex, String input){
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        int index = -1;
        if(m.find())
            index = m.start();
        
        return index;
    }
    
    // 实现lastIndexOf
    public static int lastIndexOf(String regex, String input){
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        int index = -1;
        while(m.find())
            index = m.start();
        
        return index;
    }
    
    // 替换全部匹配字符串
    public static String replaceAll(String regex, String input, String replacement){
        if (null == regex || regex.isEmpty()) return input;
        return input.replaceAll(regex, replacement);
    }

    // 替换第N个匹配字符串
    public static String replaceSome(String regex, String input, String replacement, int n){
        if (null == regex || regex.isEmpty()) return input;
        if (0 == n) return input.replaceFirst(regex, replacement);
        
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        int i = 0;
        StringBuffer buffer = new StringBuffer();
        while (i <= n && m.find()){
            if (i == n){
                m.appendReplacement(buffer, replacement);
                m.appendTail(buffer);
            }
            ++i;
        }
        if (0 == buffer.length())
            buffer.append(input);
        
        return buffer.toString();
    }
    
    // 萃取字符串
    public static String extract(String regex, String input){
        String ret = "";
        Pattern r = Pattern.compile(regex);
        Matcher m = r.matcher(input);
        if (m.find())
            ret = m.group();
        
        return ret;
    }
    
    // 拆分字符串
    public static String[] split(String regex, String input, int limit){
        if (null == input || input.isEmpty() 
                || null == regex || regex.isEmpty()) return new String[]{input};
        return input.split(regex, limit);
    }
}

   实际应用时当然不会像上面那么简单了。

六、Java支持的正则表达式功能语法                       

  本节内容仅针对正则表达式的高级功能语法进行叙述,而各语言的正则实现也就是这部分有所差异而已。

  1. 分组及反向引用

[a].  (子表达式) ,自动命名分组(从1开始以数字自动为分组命名),后续表达式中可通过反向引用来获取该分组的内容。例如匹配字符串“so so”的正则表达式可以是 ^(\w{2})\s(\1)$ ,其中 \1 就是反向引用。

    [b]. (?:子表达式) ,非捕获分组,该类型的分组将不纳入匹配对象的group属性中,并且无法通过反向引用在表达式的后续部分获取该分组的内容。通常是配合 | 使用。例如匹配字符串"so easy"和"so hard"的正则表达式可以是 so\s(?:easy|hard)

  [c].  (?<name>子表达式) ,命名分组,该类型的分组将纳入匹配对象的group属性中,并且可以在group属性值中通过name值来获取该分组的值。

    [d].  (?#注释) ,注释分组,该类型分组的内容将被正则表达式编译器忽略,仅供码农查阅而已。

  2. 零宽先行断言

零宽先行断言初看之下有点不知所云的感觉, 那么我们拆开来分析一下它的意思吧!

零宽——意思是匹配的子表达式将不被纳入匹配结果,仅作为匹配条件而已。

先行——意思是子表达式匹配的是后续字符串的内容。

    并且其细分为两类:

[a].  子表达式B(?=子表达式A) ,零宽正向先行断言(也称为预搜索匹配)。例如匹配字符串"abcd"中的a和b的正则表达式可以是 \w(?=\w{2})

[b].  子表达式B(?!子表达式A) ,零宽负向先行断言(也称为预搜索不匹配)。例如匹配字符串"abcd"中的c和d的正则表达式可以是 \w(?!\w{2})

  3. 零宽后行断言

后行——意思是子表达式匹配的是前面字符串的内容。

[a]. (?<=子表达式A)子表达式B ,零宽正向后行断言(也称为反向搜索匹配)。例如匹配字符串"abcd"中的c和d的正则表达式可以是 (?<=\w{2})\w

[b]. (?<!子表达式A)子表达式B ,零宽负向后行断言(也称为反向搜索不匹配)。例如匹配字符串"abcd"中的a和b的正则表达式可以是 (?<!\w{2})\w

  4. 平衡组

    作用:用于匹配左右两边开始、结束符号数量对等的字符串。

    示例——萃取"<div>parent<div>child</div></div></div>"的子字符串"<div>parent<div>child</div></div>"

    失败的正则表达式: <div>.*</div> ,匹配结果为"<div>parent<div>child</div></div></div>"。

    成功的正则表达式: ((?'g'<div>).*?)+(?'-g'</div>)+ ,匹配结果为"<div>parent<div>child</div></div>"。

    在分析上述示例前,我们要认识一下平衡组相关的语法。

(?'name'子表达式A) ,若成功匹配子表达式A,则往名为name的栈空间压一个元素。

(?'-name'子表达式A) ,若成功匹配子表达式A,则弹出名为name的栈空间的栈顶元素,弹出元素后若栈空间为空则结束匹配

(?(name)yes表达式|no表达式) ,若名为name的栈空间非空,则使用yes表达式进行匹配,否则则使用no表达式进行匹配。

(?(name)yes表达式) ,若名为name的栈空间非空,则使用yes表达式进行匹配。

(?!) ,由于没有后缀表达式,因此总会导致匹配失败并结束匹配

    下面我们一起来分析 ((?'g'<div>).*?)+(?'-g'</div>)+ 的匹配流程吧!

<div>parent     # 步骤1,((?'g'<div>).*?)匹配成功,然后向g栈压入一个元素
<div>child      # 步骤2,((?'g'<div>).*?)匹配成功,然后向g栈压入一个元素,现在栈含2个元素
</div>          # 步骤3,(?'-g'</div>)匹配成功,然后弹出g栈的栈顶元素,现在栈含1个元素
</div>          # 步骤4,(?'-g'</div>)匹配成功,然后弹出g栈的栈顶元素,现在栈含0个元素
                # 步骤5,由于g栈为空因此结束匹配,返回<div>parent<div>child</div></div>

     从该例子我们可以知道平衡组可以解决一些棘手的文本处理问题。但遗憾的是直到JDK1.7的原生API依旧不支持平衡组的功能语法,其余功能语法均被支持。而.Net的Regex类则支持平衡组,在这方面显然全面一些。当然比js连零宽后行断言都不支持要强不少了。

2015/10/30追加

       注意:若正则表达式仅含/()/、/(?:)/或/(?=)/,则匹配任何字符串均返回匹配成功,且配结果为空字符串。而JS中 RegExp('') 所生成的是无捕获分组 /(?:)/ 。

       而仅含/(?!)/,则匹配任务字符串均返回匹配失败。

console.log(RegExp('').test("12345")) // 显示true
console.log((?:)/.test("12345")) // 显示true
console.log(/(?=)/.test("12345")) // 显示true
console.log(/()/.test("12345")) // 显示true

console.log(/(?!)/.test("12345")) // 显示false

七、总结                                   

  到这里我们已经对Java对正则表达式的支持程度有一定程度的掌握,虽然不支持平衡组但已经为我们提供强大的文本处理能力了。不过我依旧不满意那个碍眼的转义符 \ ,假如我们要写正则表达式 \w\\\{\} 但实际运用时却要写成 \\w\\\\\\{\\} ,倘若能够像JS的正则表达式字面量一样使用,那就舒畅不少了!

八、参考                                  

http://deerchao.net/tutorials/regex/regex-1.htm http://www.cnblogs.com/kissdodog/archive/2013/04/25/3043122.html

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Felix的技术分享

霍夫曼压缩算法

3308
来自专栏JMCui

读书笔记 之《Thinking in Java》(对象、集合、异常)

一、前言:     本来想看完书再整理下自己的笔记的,可是书才看了一半发现笔记有点多,有点乱,就先整理一份吧,顺便复习下前面的知识,之后的再补上。     真的...

3718
来自专栏编程微刊

JS数组去重的6种算法实现以上就是为大家提供的6种JS数组去重的算法实现,希望对大家的学习有所帮助。

2042
来自专栏程序员互动联盟

【高级编程】C++中vector使用详解

1. 在C++中的详细说明 vector是C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。 vector之所以被认为...

39511
来自专栏java学习

面试题7(考察运算符的优先级)

请选择下面代码运行后打印的结果。 public static void main(String[]args){ int x=5; int y=3; x=x+(x...

3298
来自专栏calmound

sprintf的用法

在将各种类型的数据构造成字符串时,sprintf 的强大功能很少会让你失望。由于sprintf 跟printf 在用法上几乎一样,只是打印的目的地不同而已,前者...

3466
来自专栏chenjx85的技术专栏

leetcode-28-Implement strStr()

2806
来自专栏我是攻城师

再谈方法调用与堆栈

堆内存是被多个线程共享的,而栈内存是线程私有的。堆主要用来存储运行时所有的对象数据和各种数组,简单点说通过new创建的实例,都会在堆上分配空间。堆在虚拟机启动时...

971
来自专栏偏前端工程师的驿站

(cljs/run-at (->JSVM :browser) "语言基础")

前言  两年多前知道cljs的存在时十分兴奋,但因为工作中根本用不上,国内也没有专门的职位于是搁置了对其的探索。而近一两年来又刮起了函数式编程的风潮,恰逢有幸主...

2217
来自专栏浪淘沙

利用Map统计字符串中字符出现的次数

1511

扫码关注云+社区

领取腾讯云代金券