Java:正则表达式基础

正则表达式是一种匹配和处理字符串的文本处理工具,Java主要通过java.util.regex包中的PatternMatcherPatternSyntaxException三个类来实现正则表达式。


常用语法

字符 含义
x 字符x
\ 将下一字符标记为特殊字符、文本、反向引用或八进制转义符等。
字符类 含义
[abc] a、b 或 c
[a-zA-Z] 大小写a至z
[^abc] 非a、b、c
预定义字符类 含义
. 任何字符
\d 数字:[0-9]
\D 非数字: [^0-9]
\w 单词字符:[a-zA-Z_0-9]
\s 空白字符:[ \t\n\x0B\f\r]
边界匹配器 含义
\s 空白字符:[ \t\n\x0B\f\r]
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
量词 含义
X? X,一次或一次也没有
X* X,零次或多次
X+ X,一次或多次
X{n} X,恰好 n 次
Logical 运算符 含义
XY X 后跟 Y
X|Y X 或 Y
(X) X,作为捕获组

可以在API的Pattern类中找到所有语法


Pattern与Matcher

通过静态方法Pattern.compile()编译正则表达式实例化Pattern对象,然后将想要检索的字符串传入Pattern对象的matcher()方法,生成一个Matcher对象。

Matcher类的几个重要方法:

  1. boolean find()

    尝试查找与该模式匹配的输入序列的下一个子序列。

  2. int start()

    返回以前匹配的初始索引。

  3. int end()

    返回最后匹配字符之后的偏移量。

  4. Matcher appendReplacement(StringBuffer sb, String replacement)

    实现非终端添加和替换步骤。

  5. StringBuffer appendTail(StringBuffer sb)

    实现终端添加和替换步骤。

  6. boolean matches()

    尝试将整个区域与模式匹配。

  7. boolean lookingAt()

    尝试将从区域开头开始的输入序列与该模式匹配。

  8. String replaceFirst(String replacement)

    替换模式与给定替换字符串匹配的输入序列的第一个子序列。

  9. String replaceAll(String replacement)

    替换模式与给定替换字符串相匹配的输入序列的每个子序列。

  10. Matcher reset() Matcher reset(CharSequence input)

    重置匹配器。

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

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /* Test for satrt() and end() */
        System.out.println("/* Test for satrt() and end() */");
        String regex = "\\bcat\\b";
        String input = "cat cattie cat";
        Pattern p = Pattern.compile(regex); // 实例化Pattern
        Matcher m = p.matcher(input); // 实例化 Matcher
        int count = 0;
        while (m.find()) {
            count++;
            System.out.println("Match number " + count);
            System.out.println("start(): " + m.start());
            System.out.println("end(): " + m.end());
        }

        /* Test for appendReplacement() and appendTail() */
        System.out
                .println("/* Test for appendReplacement() and appendTail() */");
        regex = "\\d";
        input = "hello1world2haha";
        m = Pattern.compile(regex).matcher(input);
        StringBuffer sb = new StringBuffer();
        while (m.find()) {
            m.appendReplacement(sb, "-");
        }
        m.appendTail(sb); // 剩下的接上
        System.out.println(sb.toString());

        /* Test for matches() and lookingAt() */
        System.out.println("/* Test for matches() and lookingAt() */");
        regex = "hello";
        input = "hellooo";
        m = Pattern.compile(regex).matcher(input);
        System.out.println("isLookingAt?: " + m.lookingAt());
        System.out.println("isMatches?: " + m.matches());

        /* Test for String replaceFirst() and ... and reset() */
        System.out.println("/* Test for String replaceFirst() and ... and reset() */");
        regex = "cat"; // 注意与第一个Test相比是少了/b边界符的
        input = "cat cattie cat";
        m = p.compile(regex).matcher(input); // 实例化 Matcher
        System.out.println("replaceFirst(): " + m.replaceFirst("dog"));
        m.reset("cat1 cat2 cat3");
        System.out.println("replaceAll(): " + m.replaceAll("dog"));
    }

}
/* Test for satrt() and end() */
Match number 1
start(): 0
end(): 3
Match number 2
start(): 11
end(): 14
/* Test for appendReplacement() and appendTail() */
hello-world-haha
/* Test for matches() and lookingAt() */
isLookingAt?: true
isMatches?: false
/* Test for String replaceFirst() and ... and reset() */
replaceFirst(): dog cattie cat
replaceAll(): dog1 dog2 dog3

Group

组是用括号划分的正则表达式,用以获取与组内的相关信息。事实上,前面提到的方法,有些是带有一个int group参数的重载,就是用于组的。

如果我们在上面的代码里调用groupCount(),都是会返回0的,因为上面的所有正则表达式都不涉及组。

几个相关的方法:

  1. String group()

    返回由以前匹配操作所匹配的输入子序列。

  2. String group(int group)

    返回在以前匹配操作期间由给定组捕获的输入子序列。

  3. int groupCount()

    返回此匹配器模式中的捕获组数。

// 接上
/* Test for group() and groupCount() */
        System.out.println("/* Test for group() and groupCount() */");
        p = Pattern.compile("(\\d+,)(\\d+)"); // 两个组
        m = p.matcher("12,34-56,78");
        System.out.println("group count is: " + m.groupCount());
        while (m.find()) {
            System.out.println("group(): " + m.group()); // 等价于group(0)
            System.out.println("group(1): " + m.group(1));
            System.out.println("group(2): " + m.group(2));
        }
/* Test for group() and groupCount() */
group count is: 2
group(): 12,34
group(1): 12,
group(2): 34
group(): 56,78
group(1): 56,
group(2): 78

首先匹配\\d+,\\d,代表group(0)

group(1)代表\\d+,

group(2)代表\\d+


split

split是实现字符串切割的方法,可以直接通过String对象调用,也可以通过Pattern对象调用。

相关方法:

  1. String[] split(String regex)

    根据匹配给定的正则表达式来拆分此字符串。

  2. String[] split(String regex, int limit)

    根据匹配给定的正则表达式来拆分此字符串。

        /* Test for split() */
        System.out.println("/* Test for split() */");
        String string = "i-1am-23leelit-456haha";
        String[] strings1 = string.split("-\\d+");
        for (String str : strings1)
            System.out.print(str + " "); // 不换行
        System.out.println("");
        // same result
        p = Pattern.compile("-\\d+");
        String[] strings2 = p.split(string);
        for (String str : strings2)
            System.out.print(str + " "); // 不换行
        System.out.println("");
        // limit
        String[] strings3 = string.split("-\\d+", 2); // limit 2
        for (String str : strings3)
            System.out.println(str); // 换行
/* Test for split() */
i am leelit haha
i am leelit haha
i
am-23leelit-456haha


material

you can also refer to the API

时间: 2024-11-08 22:21:38

Java:正则表达式基础的相关文章

java正则表达式基础知识(转)

1基础 2.1 简单字符类 构造 描述 [abc] a,b或c [^abc] 除a,b或c外的字符 [a-zA-Z] a至z 或 A至Z [a-d[m-p]] a至d 或 m至p [a-z&&[def]] d,e或f @Test public void testChar() { //匹配 b,c或d assertTrue("d".matches("[bcd]")); //匹配除 a,b,c 以外的字符 (否定) assertTrue("d&

Java正则表达式基础整理

(一)正则表达式及语法简介 String类使用正则表达式的几个方法: 正则表达式支持的合法字符: 特殊字符: 预定义字符: 方括号表达式: 圆括号表达式:用于将多个表达式组成一个子表达式,可以使用或运算符“|”,比如正则表达式:"(aa|bb|cc)"就表示匹配"aa"."bb"."cc"三个字符串中的其中一个. 边界匹配符: 贪婪.勉强.占有模式的数量标识符: (二)Java正则表达式的简单用法 两个关键类:(1)Patte

Java 正则表达式之捕获组

Java 正则表达式之捕获组 1. Java 正则表达式基础 2. Java 正则表达式之捕获组 一.概述 1.1 什么是捕获组 捕获组就是把正则表达式中子表达式匹配的内容,保存到内存中以数字编号或显式命名的组里,方便后面引用.当然,这种引用既可以是在正则表达式内部,也可以是在正则表达式外部. 捕获组有两种形式,一种是普通捕获组,另一种是命名捕获组,通常所说的捕获组指的是普通捕获组.语法如下: 普通捕获组:(Expression) 命名捕获组:(?<name>Expression) 普通捕获组

Java Script基础(十二) 正则表达式

Java Script基础(十二) 正则表达式 一.正则表达式中常用的符号 虽然可以使用string函数来完成验证,但是这种验证方式不够严谨,而且编写比较麻烦.而正则表达式是一种描述字符模式的对象,由一些特殊的符号组成,其组成的字母模式用来匹配各种表达式.下表中列举出常用的符号和用法. 正则表达式中常用的符号和用法 符号 描述  /....../  代表一个模式的开始和结束.  ^  匹配字符串的开始   $  匹配字符串的结束  \s  任何空白字符   \S  任何非空白字符   \d  匹

正则表达式基础及java使用

正则表达式基础 正则表达式语法(1) 普通字符:字母,数字,汉子,下划线以及没有特殊定义的标点符号都是"普通字符".表达式中的普通字符,在匹配一个字符串的时候,匹配与之相同的一个字符 简单的转义字符: \n :代表换行符 \t :代表制表符 \\ :代表\本身 \^ ......  :代表匹配这字符本身 正则表达式语法(2) 标准字符集合: 能够与多种字符匹配的表达式 注意区分大小写,大写是相反的意思 \d :任意一个数字,0-9中的任意一个 \w:任意一个字母或者下划线或者汉字,也就

java正则表达式入门基础

一.正则表达式术语 1)元字符 : 非一般字符,具有某种意义的字符.如 : \bX : \b边界符, 以 X开始的单词 2) 常用 : \d : 匹配一个数字 : \d ,  匹配至少一个以上数字 \d+ \b : 单词边界符 , 如 \bhe 则匹配以he开头的单词, hello等 \w : 与"[A-Za-z0-9_]"等效. 如 \w+ 匹配字符串1,2,3a(bc4,)5,6(e)f78(g) 结果为  123abc456ef78g () : 以 括号内的整串重复出现,如 : 

JAVA 正则表达式 (超详细)

(PS:这篇文章为转载,我不喜欢转载的但我觉得这篇文章实在是超赞了,就转了过来,这篇可以说是学习JAVA正则表达的必读篇.作者是个正真有功力的人,阅读愉快) 在Sun的JavaJDK 1.40版本中,Java自带了支持正则表达式的包,本文就抛砖引玉地介绍了如何使用java.util.regex包. 可粗略估计一下,除了偶尔用Linux的外,其他Linu x用户都会遇到正则表达式.正则表达式是个极端强大工具,而且在字符串模式-匹配和字符串模式-替换方面富有弹性.在Unix世界里,正则表达式几乎没有

Java 正则表达式(精华)

英文:Jakob Jenkov译文:严亮链接:ifeve.com/java-regex/ Java 提供了功能强大的正则表达式API,在java.util.regex 包下.本教程介绍如何使用正则表达式API. 正则表达式 一个正则表达式是一个用于文本搜索的文本模式.换句话说,在文本中搜索出现的模式.例如,你可以用正则表达式搜索网页中的邮箱地址或超链接. 正则表达式示例 下面是一个简单的Java正则表达式的例子,用于在文本中搜索 http:// String text = "This is th

Java 正则表达式详解

摘自:http://www.jb51.net/article/16829.htm 许多语言,包括 Perl.PHP.Python.JavaScript和JScript,都支持用正则表达式处理文本,一些文本编辑器用正则表达式实现高级“搜索-替 换”功能.那么Java又怎样呢?本文写作时,一个包含了用正则表达式进行文本处理的Java规范需求(Specification Request)已经得到认可,你可以期待在JDK的下一版本中看到它. 然而,如果现在就需要使用正则表达式,又该怎么办呢?你可以从Ap

JAVA正则表达式高级用法(分组与捕获)

正则表达式在字符串处理中经常使用,关于正则简单的用法相信有一点程序基础的人都懂得一些,这里就不介绍简单基础了.这里主要讲解一下在JAVA中实现了的正则的高级用法-分组与捕获.对于要重复单个字符,非常简单,直接在字符后卖弄加上限定符即可,例如 a+ 表示匹配1个或一个以上的a,a?表示匹配0个或1个a.这些限定符如下所示: X ?     X ,一次或一次也没有X *     X ,零次或多次X +     X ,一次或多次X { n }     X ,恰好 n 次X { n ,}     X ,