12、正则表达式中的Matcher类总结

最新推荐文章于 2023-11-08 16:51:04 发布
最新推荐文章于 2023-11-08 16:51:04 发布
阅读量507 收藏
点赞数
分类专栏： Java基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heruozhi/article/details/44538723
版权

正则表达式不多介绍，记住要

import java.util.regex.*;


主要总结一下Pattern和Matcher的一些东西。

先看代码：

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "1588344570615883445706";
		Matcher m = Pattern.compile("(((13\\d)|(15\\d))\\d{8})+?").matcher(str);		
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}

Pattern.compile是一个类方法，查阅API文档可知，compile有两种重载，一种是compile(String regex)，另一种多一个参数compile(String regex, int flags)，flags是一个用以约束的描述符，有一些宏与其对应。compile返回一个 Pattern对象，Pattern没有可见的构造器。Pattern有一些方法，不过不是重点，Pattern对象保存着compile的参数，可以产生Matcher对象，Matcher对象是重点。

Matcher的构造器也是不可见的，只能通过Pattern对象的matcher(String str)方法产生Matcher实例，Pattern为什么可以调用Matcher的构造器？我表示疑惑，有空研究一下源码。

关于Matcher归类简介几点：

1、匹配。

匹配主要有find()、lookingAt()和matches()，它们都返回一个boolean值，表示是否找到了匹配的结果

find()：文档中这样说：Attempts to find the next subsequence of the input sequence that matches the pattern. 即是在输入的序列中去找“下一个”匹配模版的子序列。这里的“找”如果找到了，则把结果存在某处，返回一个true，用group()方法就可以把这个已经存好的结果输出。find()从头到位把序列检查一遍之后就不再检查，之后会一直输出false。使用find(int start)可以设定一个起始位置重新开始查找。

比如最上方的代码，((13\\d)|(15\\d))\\d{8} 表示“13x开头，或者15x开头，后面有八个x” x代表数字。其实也可以写成((13)|(15))\\d{9}。把这个式子括起来，加上数量表示符“+?”。加号表示的条件是：前面的式子出现一次或者多次。问号表示“勉强模式”：匹配最少的字符。所以这个条件就是寻找模版只出现一次的情况。

第一次调用find()，找到前11位，m.group()输出一个String结果。再次调用find()，找到后11位，group()又输出一个结果。此时已经到了字符串的结尾，第三次调用find()将返回false，循环结束。

所以程序的结果是：

start at : 0;end at :11 output : 15883445706
start at : 11;end at :22 output : 15883445706


lookingAt()：

这个方法只查找字符串的开头，开头能够匹配则返回true，否则返回false。所以如果在上述程序中使用

while(m.lookingAt())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
就会一直循环下去，检查开头----匹配-----输出-----检查开头-----匹配-----输出……


matches()：

这个方法检查整个字符串，把程序修改如下

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "1588344570615883445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})+").matcher(str);		
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}
可以看到，正则表达式尾部的数量表示符只有一个“+”，表示此式子出现一次或者多次，加号之后没有其他限定，默认采用“贪婪模式”，即允许的范围内尽量多，所以会匹配“多次”，而“多次”这个概念没有上限，所以会匹配到无法匹配为止。

所以结果是，一次性把两个相连的电话号码都匹配了，输出：

start at : 0;end at :22 output : 1588344570615883445706

2、Matcher每次查找匹配之后的定位行为：

find()的行为，以以下代码为例：

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "1588344570615883d445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})?").matcher(str);//零次或一次，贪婪模式	
//		System.out.println(m.groupCount());
//	        m.matches();
//		System.out.println(m.start(0));
//		System.out.println(m.start(1));
//		System.out.println(m.start(2));
//		System.out.println(m.start(3));
//              m.lookingAt();		
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}
结果是：

start at : 0;end at :11 output : 15883445706
start at : 11;end at :-1 output : 
start at : 12;end at :-1 output : 
start at : 13;end at :-1 output : 
start at : 14;end at :-1 output : 
start at : 15;end at :-1 output : 
start at : 16;end at :-1 output : 
start at : 17;end at :-1 output : 
start at : 18;end at :-1 output : 
start at : 19;end at :-1 output : 
start at : 20;end at :-1 output : 
start at : 21;end at :-1 output : 
start at : 22;end at :-1 output : 
start at : 23;end at :-1 output : 

可以发现，匹配到第一个正确的号码后，没有再找到能够匹配“一次”的结果，于是回到上一次的结果的后一个字符，开始匹配“零次”。


lookingAt的行为，以以下代码为例：

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "158d8344570615883445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})?").matcher(str);	
//		System.out.println(m.groupCount());
//	        m.matches();
//		System.out.println(m.start(0));
//		System.out.println(m.start(1));
//		System.out.println(m.start(2));
//		System.out.println(m.start(3));
		m.lookingAt();		
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}
结果是：

start at : 1;end at :-1 output : 
start at : 2;end at :-1 output : 
start at : 3;end at :-1 output : 
start at : 4;end at :-1 output : 
start at : 5;end at :-1 output : 
start at : 6;end at :-1 output : 
start at : 7;end at :-1 output : 
start at : 8;end at :-1 output : 
start at : 9;end at :-1 output : 
start at : 10;end at :-1 output : 
start at : 11;end at :-1 output : 
start at : 12;end at :23 output : 15883445706
start at : 23;end at :-1 output : 
虽然lookingAt在开头匹配成功，因为匹配多次不成功之后，尝试匹配“零次”，并在第一个字符成功，定位后移了一位，find是从第1位开始匹配“零次”的。

如果lookingAt匹配成功，则定位在之后一位，跟find一样。


matches()的行为比较奇怪，看如下代码：

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "158d8344570615883445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})??").matcher(str);	
                m.matches();	
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}
输出结果是：

start at : 3;end at :-1 output : 
start at : 4;end at :-1 output : 
start at : 5;end at :-1 output : 
start at : 6;end at :-1 output : 
start at : 7;end at :-1 output : 
start at : 8;end at :-1 output : 
start at : 9;end at :-1 output : 
start at : 10;end at :-1 output : 
start at : 11;end at :-1 output : 
start at : 12;end at :-1 output : 
start at : 13;end at :-1 output : 
start at : 14;end at :-1 output : 
start at : 15;end at :-1 output : 
start at : 16;end at :-1 output : 
start at : 17;end at :-1 output : 
start at : 18;end at :-1 output : 
start at : 19;end at :-1 output : 
start at : 20;end at :-1 output : 
start at : 21;end at :-1 output : 
start at : 22;end at :-1 output : 
start at : 23;end at :-1 output : 

显然，matches()发现从第三位起匹配失败了，于是定位停在了这里（失败那一位），然后find从第三位起开始匹配“零次”

再看如下代码：

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "1588344570615883445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})+?").matcher(str);//一次或多次，勉强模式	
        m.matches();	
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}
结果是什么也没有输出。虽然是数量表示符是+?，即一次或多次并使用勉强模式，但是matches()还是把整个字符串都匹配进去了。同样的，如果数量表示符是*?，在“零次或多次，勉强模式”的条件下，matches()一样把整个字符串匹配进去了。

事实证明，matches根本不受“勉强模式”的约束。其实也有道理，都拿整个字符串来检查了，还要什么勉强模式呢，当然以匹配最多为准。

而且，如果使用??，即“零次或一次，勉强模式”，代码如下：

package c71;

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "1588344570615883445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})??").matcher(str);	
                System.out.println(m.matches());        	
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}
结果是：

false
start at : 11;end at :-1 output : 
start at : 12;end at :-1 output : 
start at : 13;end at :-1 output : 
start at : 14;end at :-1 output : 
start at : 15;end at :-1 output : 
start at : 16;end at :-1 output : 
start at : 17;end at :-1 output : 
start at : 18;end at :-1 output : 
start at : 19;end at :-1 output : 
start at : 20;end at :-1 output : 
start at : 21;end at :-1 output : 
start at : 22;end at :-1 output : 

可以想象matches执行的过程，检查完第一个电话号码，还是对的（定位在10），准备往下检查（定位来到11），但是发现只允许检查一个，于是就像遇到错误一样的反应，定位停在当前位置，并返回一个false。


3、关于匹配“零次”：

如果数量表示符允许匹配零次，比如(((13)|(15))\\d{9})*，星号表示零次或者多次。不加其他限制默认采用“贪婪模式”，则会输出：

start at : 0;end at :22 output : 1588344570615883445706
start at : 22;end at :-1 output : 

即把一个“多次”匹配完之后，在最末尾匹配了一次“零次”，这个零次起始于第22个字符，也就是\0结束符。


如果用(((13)|(15))\\d{9})?，一个问号表示零次或一次的“贪婪模式”，结果是：

start at : 0;end at :11 output : 15883445706
start at : 11;end at :22 output : 15883445706
start at : 22;end at :-1 output : 

同样在匹配两个“一次”之后，匹配了一个“零次”。

把代码改为

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "15883445706df15883445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})?").matcher(str);		
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}

结果是：

start at : 0;end at :11 output : 15883445706
start at : 11;end at :-1 output : 
start at : 12;end at :-1 output : 
start at : 13;end at :24 output : 15883445706
start at : 24;end at :-1 output : 
结果证明：如果允许匹配“零次”，则会在每个不匹配的字符上find()成功，包括结尾的\0。同样地，如果第一个字符不匹配，lookingAt()也会对第一个字符匹配“零次”成功。


不难推测：如果数量表示符里面允许匹配零次，再使用“勉强模式”会出现以下现象，比如代码：

import java.util.regex.*;

public class RegExPrac {
	public static void main(String[] args)
	{
		String str = "1588344570615883445706";
		Matcher m = Pattern.compile("(((13)|(15))\\d{9})*?").matcher(str);		
		while(m.find())
		{
			System.out.println("start at : " + m.start() + ";end at :"
		                           + m.end(1) + " output : " + m.group());
		}
	}
}
*?表示零次或多次并使用“勉强模式”，即匹配“零次”，结果是

start at : 0;end at :-1 output : 
start at : 1;end at :-1 output : 
start at : 2;end at :-1 output : 
start at : 3;end at :-1 output : 
start at : 4;end at :-1 output : 
start at : 5;end at :-1 output : 
start at : 6;end at :-1 output : 
start at : 7;end at :-1 output : 
start at : 8;end at :-1 output : 
start at : 9;end at :-1 output : 
start at : 10;end at :-1 output : 
start at : 11;end at :-1 output : 
start at : 12;end at :-1 output : 
start at : 13;end at :-1 output : 
start at : 14;end at :-1 output : 
start at : 15;end at :-1 output : 
start at : 16;end at :-1 output : 
start at : 17;end at :-1 output : 
start at : 18;end at :-1 output : 
start at : 19;end at :-1 output : 
start at : 20;end at :-1 output : 
start at : 21;end at :-1 output : 
start at : 22;end at :-1 output : 

没有得到任何电话号码，而是在每个字符上匹配了一次“零次”。

这么看起来，还是用“+?”控制最好，一次或者多次中用“勉强模式”，即刚好一次。

4、输出

输出其实就是用刚才说的group()，输出当前被匹配到的结果，注意必须要先用上面那三个方法之一匹配一下得到确认返回为true，有结果，再输出，不然会出异常：java.lang.IllegalStateException

同时， 可以用start()、end()方法分别输出当前匹配的结果在源字符串中的起始位置和结束位置，结束位置是字符串最后一个字符位置再往后一位，java的习惯。

group，start，end三个方法都有带参数的重载，比如group(int group)，start(int group)，end(int group)，这些参数好像只有在matches检查整个字符串之后才有意义，而group到底是怎么分，怎么算的，暂时还没弄明白。

heruozhi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
正则表达式的验证
梦溪笔谈
07-16 623
java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳). Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工...
详解Java正则表达式中Pattern类和Matcher类
08-27
java.util.regex是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。包括两个类Pattern和Matcher Pattern，Pattern是一个正则表达式经编译后的表现模式。Matcher对象是一个状态机器，它依据Pattern对象做为匹配模式对字符串展开匹配检查。
正则表达式（Matcher类）
技术文章
12-25 719
Matcher类:      使用Matcher类,最重要的一个概念必须清楚:组(Group),在正则表达式中 ()定义了一个组,由于一个正则表达式可以包含很多的组,所以下面先说说怎么划分组的, 以及这些组和组的下标怎么对应的.  下面我们看看一个小例子,来说明这个问题  \w(\d\d)(\w+) 这个正则表达式有三个组:  整个\w(\d\d)(\w+) 是第0组>
正则表达式 ----Matcher类
qq_46093575的博客
06-02 814
一、Matcher类
第十六章《正则表达式》第4节：Matcher类
穆哥学堂--Java学习园地
11-30 795
如果程序员想用正则表达式完成替换等更复杂的操作，必须使Matcher类。Matcher是执行匹配操作的引擎，它位于java.util.regex包下，使用这个类时需要用import关键字进行引入，本小节将详细讲解Matcher类的使用。
正则表达式：Pattern,Matcher
China_Guanq的博客
06-12 556
  标记： Pattern:用户创建正则表示式，匹配模式(也就是正则表示式编译表达的形式) Matcher:执行匹配操作的引擎 1、创建一个正则表示式：   Pattern p1 = Pattern.compile("\\d+");     部分代码示例： //split：截取字符串 Pattern p1 = Pattern.compile("\\d+"); String[] str ...
详解正则表达式Matcher类中group方法
10-16
主要介绍了正则表达式Matcher类中group方法，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
Java正则表达式Pattern和Matcher原理详解
08-24
主要介绍了Java正则表达式Pattern和Matcher原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java正则表达式.zip
08-21
在Java中，正则表达式主要通过`java.util.regex`包来实现，提供了Pattern和Matcher两个核心类。 **1. Pattern类** Pattern类是Java正则表达式的起点，它将一个正则表达式编译成一个模式对象。这个编译过程可以优化...
java 正则表达式Pattern Matcher的使用
CNZYYH的博客
12-03 621
以下是几个使用的demo 整个字符串是否匹配正则： import java.util.regex.Matcher; import java.util.regex.Pattern; public class isMatchesZhengze { public static void main(String[]args){ Pattern p = Pattern.compile("(\\...
正则表达式matcher.group用法
kqixiang945的专栏
09-25 101
group是针对括号（）来说的，group（0）就是指的整个串，group（1） 指的是第一个括号里的东西，group（2）指的第二个括号里的东西。 上代码： 1 @Test 2 public void test1() { 3 Pattern pattern = Pattern.compile("页面下载失败\\.url:\\[http:...
正则表达式(二) -Pattern与Matcher用法
alvin的博客
10-10 519
String str5 = "8OABCE[34][AA]"; Pattern pattern = Pattern.compile("(\\[\\d+\\])(\\[[0-9a-zA-Z]+\\])$"); Matcher matcher = pattern.matcher(str5); while (matcher.find()) {
正则表达式Matcher、Pattern、String对正则表达式的使用
weixin_44342481的博客
02-01 282
[1234] 表示 1,2,3,4 之一 [^12] 表示除了 1,2 [1-5] 表示 1,2,3,4,5 [a-f] 表示 a-f 之间的 [0-9a-fA-F] 表示一个16进制字符 0[xX][0-9a-fA-F]{1,8} 表示整数的16进制数表达式 [\w-]{8,15} 表示8-15个字母、下划线、数字及“-” \d 表示[0-9] “.”点 表示任意字符 \w 表示单个字符 [0-9a-zA-Z_] 注：包含下划线“” \W （不常用）表示非单词字符 [^0-9a-zA-Z]
java中正则表达式Pattern与Matcher类使用详解(find、group)
祁东握力的博客
05-25 8693
一、Pattern的使用 这个使用很简单。 1、把正则表达式编译为Pattern对象： 比如： Pattern compile = Pattern.compile("http://([a-z]+\\.)+[a-z]+"); 就是用于匹配http的url的正则表达式（随手写的，可能有bug），利用compile静态方法创建对应的Pattern实例对象。 2、Pattern里面两个有用的...
学习Java（7）之正则表达式
我的博客
05-25 482
1.运用正则表达式判断字符串是否包含数字 HasNum.java import java.util.Scanner; import java.util.regex.*; public class HasNum { public static void main(String[] args) { String reg = "\\d"; Pattern pattern = Pattern.compile(reg); Scanner s =new Scanner(System.in); Sys
Matcher()中的m.find()和matches()比较为什么不同?
qq_46603402的博客
04-06 780
目录 前提知识 Pattern和Matcher类 使用方法 问题引入 问题总结 前提知识 Pattern和Matcher类 Pattern类的对象是模式器，正则表达式的编译表示形式。封装的是正则表达式，返回这个模式器，可在API中查看。 Matcher类的对象是匹配器。 指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同
java&正则表达式（Pattern类和Matcher类）
最新发布
Bananaaay的博客
11-08 2239
对正则表达式以及java中使用正则表达式的整理
记录正则表达式matcher.find()的问题
qq_32471941的博客
05-18 1528
matcher.find()一直为false的问题
Java内置的正则表达式和Matcher类 MessageUtils.replaceMessage Cannot resolve method 'replaceMessage' in 'MessageUtils'
05-11
关于Java内置的正则表达式和Matcher类，可以通过以下方式使用： 1. 定义正则表达式 ```java String regex = "your-regex-pattern"; ``` 2. 编译正则表达式 ```java Pattern pattern = Pattern.compile(regex); ``` 3. 创建Matcher对象，并匹配字符串 ```java Matcher matcher = pattern.matcher(yourString); ``` 4. 使用Matcher类的方法进行匹配和替换操作 例如，使用Matcher的replaceAll方法替换匹配到的字符串： ```java String newString = matcher.replaceAll("replacement-string"); ``` 关于MessageUtils.replaceMessage方法找不到的问题，可能是因为该方法不存在或者参数不正确。请检查该方法的定义和使用，并确保参数类型和数量正确。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值