[01] Pattern类和Matcher类

在Java中,有个java.util.regex包,这是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。

它主要有两个类:

  • Pattern   一个正则表达式经编译后的表现模式,可以理解为某正则的对应类
  • Matcher  匹配检查器,根据Pattern对象作为匹配模式对字符串进行匹配检查

1、Pattern

1.1 获取Pattern对象

Pattern类用于创建一个正则表达式,或者说创建一个匹配模式对象,我们不能直接创建,需要使用其静态方法compile实现:

  • static Pattern   Pattern.compile(String regExp)

如果已有Pattern对象,希望返回其对应的正则表达式的字符串形式,则可以使用Pattern对象的pattern()方法,如下:

  1. Pattern p = Pattern.compile("\\w+");
  2. p.pattern(); //返回 \w+

总结:

Pattern     Pattern.compile(String regExp) 返回正则表达式对应的Pattern对象
String     pattern()     返回Pattern对象对应的正则表达式的字符串形式

1.2 分隔字符串

Pattern有一个split(CharSequence input)方法,用于分隔字符串,其中Pattern对应的正则表达式匹配的字符串作为分隔符,并返回一个String[]。(CharSequence是一个接口,其实现类有String,StringBuffer,StringBuilder等)

如下例:

  1. Pattern p=Pattern.compile("\\d+");
  2. String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:[email protected]");
  3. //结果:str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:[email protected]"

总结:

String[] split(CharSequence input)     符合匹配规则的字符串作为分隔符,分隔字符串并返回字符串数组

1.3 判断是否完整符合匹配规则

Pattern.matcher(String regex,CharSequence input)是一个静态方法,用于快速匹配字符串,且匹配全部字符串。即相当于判断当前字符串是否完整符合匹配规则(注意,字符串中有子串符合匹配规则,也是不行的,返回false)

如下例:

  1. Pattern.matches("\\d+","2223");//返回true
  2. Pattern.matches("\\d+","2223aa");//返回false,需要匹配到所有字符串才能返回true,这里aa不符
  3. Pattern.matches("\\d+","22bb23");//返回false,需要匹配到所有字符串才能返回true,这里bb不符

总结:

boolean matches(String regex, CharSequence input) 判断字符串是否完整匹配对应的正则表达式

2、Matcher

2.1 获取Matcher对象

Matcher对象需要通过Pattern对象来获取,调用某个Pattern对象的matcher(CharSequence input)方法来返回一个Matcher对象。Pattern类只能做一些简单的匹配操作,需要更强更便捷的正则匹配操作,则需要结合Matcher协同作业。Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持。

如下例:

  1. Pattern p = Pattern.compile("\\d+");
  2. Matcher m = p.matcher("22bb23");
  3. m.pattern(); //返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的

总结:

Matcher matcher(CharSequence input)  返回一个对应Pattern的Matcher对象

2.2 判断匹配规则

2.2.1 完整匹配判断

刚才我们提到Pattern的一个静态方法Pattern.matcher(String regex,CharSequence input),可以用来对整个字符串进行正则匹配,符合才返回true。在Matcher中也有相同效果的方法matches()

如下例:

  1. Pattern p = Pattern.compile("\\d+");
  2. Matcher m = p.matcher("22bb23");
  3. m.matches(); //返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功.
  4. Matcher m2 = p.matcher("2223");
  5. m2.matches(); //返回true,因为\d+匹配到了整个字符串

总结:

boolean matches() 判断对应字符串是否完全匹配正则表达式

2.2.2 开头匹配判断

lookiingAt()则是对字符串的开头进行匹配,即只有从头开始的子串符合正则,才返回true,如下例:

  1. Pattern p = Pattern.compile("\\d+");
  2. Matcher m = p.matcher("22bb23");
  3. m.lookingAt(); //返回true,因为\d+匹配到了前面的22
  4. Matcher m2 = p.matcher("aa2223");
  5. m2.lookingAt(); //返回false,因为\d+不能匹配前面的aa

总结:

boolean lookingAt() 符合正则的子串是否位于字符串首位

2.2.3 子串匹配判断

find()则相当于在整个字符串不限位置进行匹配,只要包含符合正则的子串,则返回true,如下例:

  1. Pattern p = Pattern.compile("\\d+");
  2. Matcher m = p.matcher("22bb23");
  3. m.find(); //返回true
  4. Matcher m2 = p.matcher("aa2223");
  5. m2.find(); //返回true
  6. Matcher m3 = p.matcher("aa2223bb");
  7. m3.find(); //返回true
  8. Matcher m4 = p.matcher("aabb");
  9. m4.find(); //返回false

注意,find方法是可以重复调用的,它就像一个游走在字符串的光标,也就是说假如字符串包含多个匹配子串,第一次调用在查找到首个子串存在时候返回true,再次调用find方法时,会跳过已经匹配的子川往后匹配,如果还有则再次返回true,直到找不到为止。如下例:

  1. Pattern pattern = Pattern.compile("\\d+");
  2. Matcher matcher = pattern.matcher("aaa2223bb222");
  3. while (matcher.find()) {
  4. System.out.println("ok");
  5. }
  6. //会输出两次ok,第一次匹配到了2223,第二次匹配到了尾部的222

总结:

boolean find() 判断是否存在符合正则的子串,可以重复调用直到找不到符合匹配的子串为止

2.3 子串匹配

不论是通过上述的matches(),还是lookingAt()、find(),只要我们已经确认了字符串中包含符合正则的子串(完整匹配的子串就是它本身),我们就可以利用start()、end()、group()来进一步得到该匹配子串的详细信息:

  • start()  返回匹配子串在字符串中的索引位置
  • end()  返回匹配子串的最后一个字符在字符串中的索引位置
  • group()  返回匹配到的子串

如下例:

  1. Pattern p = Pattern.compile("\\d+");
  2. Matcher m = p.matcher("aaa2223bb");
  3. m.find(); //返回true,匹配2223
  4. m.start(); //返回3
  5. m.end(); //返回7, 返回的是2223后的位置,非索引号
  6. m.group(); //返回2223

另外要注意的是,不乱是start、end、group,都是随着匹配操作进行而改变的。刚才我们提到find()方法类似游走的光标,可以循环调用,每次调用后,上述三个方法都是针对的新的子串,而不再是最开始的那个。如下例:

  1. Pattern pattern = Pattern.compile("\\d+");
  2. Matcher matcher = pattern.matcher("aaa2223bb222");
  3. System.out.println(matcher.find());
  4. System.out.println(matcher.group()); //返回2223
  5. System.out.println(matcher.group()); //返回2223
  6. System.out.println(matcher.group()); //返回2223
  7. //因为上述find没有再次进行操作,那么下面我们将find循环调用
  8. while (matcher.find()) {
  9. System.out.println(matcher.group() + " - " + matcher.start() + ", " + matcher.end());
  10. }
  11. //会得到两个输出
  12. //2223 - 3, 7
  13. //222 - 9, 12

总结:

int start()     返回匹配子串在字符串中的索引位置    
int     end()     返回匹配子串最后一个字符在字符串中的位置(非索引)
String     group()     返回匹配到的子串

2.4 分组操作

我们知道,正则表达式还可以进一步提取子串,用括号 ( ) 表示的就是要提取的分组。所谓组,就是更细化地分化你所匹配到的字符串。

start、end、group这三个方法还有重载方法start(int i)、end(int i)、group(int i),这三个方法就是用于分组操作,同时Matcher类还有一个groupCount()方法用于返回组数。如下例:

  1. Pattern pattern = Pattern.compile("([a-z]+)(\\d+)");
  2. Matcher matcher = pattern.matcher("aaa2223bb222xxx88");
  3. System.out.println(matcher.groupCount());
  4. System.out.println("========");
  5. while (matcher.find()) {
  6. System.out.println(matcher.group());
  7. System.out.println(matcher.group(1));
  8. System.out.println(matcher.group(2));
  9. System.out.println("--------");
  10. }

上述([a-z]+)(\\d+),分了两组,这个两组,是说匹配到的字符串由这两部分组成。

看输出结果即可明白,如第一个符合正则的子串aaa2223,其分组中:

  • 第一组为aaa,对应([a-z]);
  • 第二组为2223,对应(\\d+)
  1. 2
  2. ========
  3. aaa2223
  4. aaa
  5. 2223
  6. --------
  7. bb222
  8. bb
  9. 222
  10. --------
  11. xxx88
  12. xxx
  13. 88
  14. --------

总结:

int start(int i)     返回第 i 组匹配到的子串在字符串中的索引位置    
int     end(int i)     返回第 i 组匹配子串最后一个字符在字符串中的位置(非索引号)
String     group(int i)     返回匹配到的字符串中第 i 组子串

3、参考链接

时间: 2024-10-19 05:51:17

[01] Pattern类和Matcher类的相关文章

JAVA正则表达式:Pattern类与Matcher类详解(转)

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包.它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式. Matcher 一个Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查. 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式,然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作

JAVA正则表达式:Pattern类与Matcher类详解

java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包.它包括两个类:Pattern和Matcher Pattern 一个Pattern是一个正则表达式经编译后的表现模式. Matcher 一个Matcher对象是一个状态机器,它依据Pattern对象做为匹配模式对字符串展开匹配检查. 首先一个Pattern实例订制了一个所用语法与PERL的类似的正则表达式经编译后的模式,然后一个Matcher实例在这个给定的Pattern实例的模式控制下进行字符串的匹配工作

java中使用Pattern类中和Matcher类进行查找和替换,你会吗?

前言 无论是哪一门语言,我们总会用到正则表达式来进行字符串的查找和替换.Java中也不为过,我曾经写过一个网页---正则表达式在线测试.那时候,我还没有开始学习Java,不知道Java支持正则表达式,所以我的第一个方案是想办法将数据传输到后台,然后利用Shell脚本正则表达式得到匹配结果.如果后来真的那么做了,那就二了.后来我研究了以下别的类似的网站,发现甚至连js文件都不用写,直接将函数写在html文件中就能够完成这一个任务.一天的时间,我把这个网站给写了出来.所以,即使不是脚本型语言,了解以

正则表达式:Pattern类与Matcher类详解

一.捕获组的概念 捕获组可以通过从左到右计算其开括号来编号,编号是从1 开始的.例如,在表达式((A)(B(C)))中,存在四个这样的组: 1     ((A)(B(C))) 2     (A) 3     (B(C)) 4     (C) 组零始终代表整个表达式. 以(?) 开头的组是纯的非捕获 组,它不捕获文本,也不针对组合计进行计数. 与组关联的捕获输入始终是与组最近匹配的子序列.如果由于量化的缘故再次计算了组,则在第二次计算失败时将保留其以前捕获的值(如果有的话)例如,将字符串"aba&

详解Pattern类和Matcher类

java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳). Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式, Java代码示例: Pattern p=Pattern.compile("\\w+

14-01 Java matches类,Pattern类,matcher类

Pattern类 正则表达式常见规则 A:字符 x 字符 x.举例:'a'表示字符a \\ 反斜线字符. \n 新行(换行)符 ('\u000A') \r 回车符 ('\u000D') B:字符类 [abc] a.b 或 c(简单类),其中一个 [^abc] 任何字符,除了 a.b 或 c(否定) [a-zA-Z] a到 z 或 A到 Z,两头的字母包括在内(范围) [0-9] 0到9的字符都包括 C:预定义字符类 . 任何字符.我的就是.字符本身,怎么表示呢? \. \d 数字:[0-9] \

Pattern类和Matcher类

Pattern类的主要作用是进行正则规范的编写,而Matcher类主要是执行规范,验证一个字符串是否符合其规范.下面来通过具体例子了解一下: import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexDemo { public static void main(String[] args) { String string = "1983-07-27"; String patStri

正则表达式:Matcher类

Matcher类: 使用Matcher类,最重要的一个概念必须清楚:组(Group),在正则表达式中 ()定义了一个组,由于一个正则表达式可以包含很多的组,所以下面先说说怎么划分组的, 以及这些组和组的下标怎么对应的. 下面我们看看一个小例子,来说明这个问题 \w(\d\d)(\w+) 这个正则表达式有三个组: 整个\w(\d\d)(\w+) 是第0组 group(0) (\d\d)是第1组 group(1) (\w+)是第2组 group(2) 我们看看和正则表达式匹配的一个字符串x99Sup

Java基础知识强化78:正则表达式之获取功能(Pattern 和 Matcher类的使用)

1. 获取功能: Pattern 和 Matcher类结合使用 2. 使用案例: 1 package cn.itcast_05; 2 3 import java.util.regex.Matcher; 4 import java.util.regex.Pattern; 5 6 /* 7 * 获取功能 8 * Pattern和Matcher类的使用 9 * 10 * 模式和匹配器的基本使用顺序 11 */ 12 public class RegexDemo { 13 public static v