JAVA正则表达式 Pattern和Matcher(二)ITeye - 超凡娱乐

JAVA正则表达式 Pattern和Matcher(二)ITeye

2019年03月06日10时10分55秒 | 作者: 初兰 | 标签: 正则表达式,匹配,这个 | 浏览: 435

Matcher类:
    运用Matcher类,最重要的一个概念有必要清楚:组(Group),在正则表达式中 ()界说了一个组,由于一个正则表达式能够包括许多的组,所以下面先说说怎样划分组的, 以及这些组和组的下标怎样对应的.

下面咱们看看一个小比如,来阐明这个问题

\w(\d\d)(\w+)
这个正则表达式有三个组:
整个\w(\d\d)(\w+) 是第0组 group(0)
(\d\d)是第1组 group(1)
(\w+)是第2组 group(2)

   咱们看看和正则表达式匹配的一个字符串x99SuperJava,
group(0)是匹配整个表达式的字符串的那部分x99SuperJava
group(1)是第1组(\d\d)匹配的部分:99
group(2)是第二组(\w+)匹配的那部分SuperJava

   下面咱们写一个程序来验证一下:

package edu.jlu.fuliang;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexTest {
 public static void main(String[] args) {
 String regex = "\\w(\\d\\d)(\\w+)";
 String candidate = "x99SuperJava";
 Pattern p = Pattern.compile(regex);
 Matcher matcher = p.matcher(candidate);
 if(matcher.find()){
 int gc = matcher.groupCount();
 for(int i = 0; i = gc; i++)
 System.out.println("group " + i + " :" + matcher.group(i));
 

输出成果:

 

group 099SuperJava
group 1 :99
group 2 :SuperJava



下面咱们看看Matcher类供给的办法:
public Pattern pattern()
这个办法回来了,创立Matcher的那个pattern目标。

下面咱们看看一个小比如来阐明这个成果

import java.util.regex.*;
public class MatcherPatternExample{
 public static void main(String args[]){
 test();
 public static void test(){
 Pattern p = Pattern.compile("\\d");
 Matcher m1 = p.matcher("55");
 Matcher m2 = p.matcher("fdshfdgdfh");
 System.out.println(m1.pattern()  m2.pattern());
 //return true
 

public Matcher reset()
这个办法将Matcher的状况从头设置为开端的状况。

public Matcher reset(CharSequence input)
从头设置Matcher的状况,而且将候选字符序列设置为input后进行Matcher, 这个办法和从头创立一个Matcher相同,仅仅这样能够重用曾经的目标。

public int start()
这个办法回来了,Matcher所匹配的字符串在整个字符串的的开端下标:
下面咱们看看一个小比如

public class MatcherStartExample{
 public static void main(String args[]){
 test();
 public static void test(){
 //create a Matcher and use the Matcher.start() method
 String candidateString = "My name is Bond. James Bond.";
 String matchHelper[] =
 {" ^"," ^"};
 Pattern p = Pattern.compile("Bond");
 Matcher matcher = p.matcher(candidateString);
 //Find the starting point of the first Bond
 matcher.find();
 int startIndex = matcher.start();
 System.out.println(candidateString);
 System.out.println(matchHelper[0] + startIndex);
 //Find the starting point of the second Bond
 matcher.find();
 int nextIndex = matcher.start();
 System.out.println(candidateString);
 System.out.println(matchHelper[1] + nextIndex);
 


输出成果:
My name is Bond. James Bond.
          ^11
My name is Bond. James Bond.
                      ^23

public int start(int group)
这个办法能够指定你感兴趣的sub group,然后回来sup group匹配的开端方位。

public int end()
这个和start()对应,回来在曾经的匹配操作期间,由给定组所捕获子序列的最终字符之后的偏移量。
其实start和end常常是一同合作运用来回来匹配的子字符串。

public int end(int group)
和public int start(int group)对应,回来在sup group匹配的子字符串最终一个字符在整个字符串下标加一

public String group()
回来由曾经匹配操作所匹配的输入子序列。
这个办法供给了强壮而便利的东西,他能够同等运用start和end,然后对字符串作substring(start,end)操作。
看看下面一个小比如:

import java.util.regex.*;
public class MatcherGroupExample{
 public static void main(String args[]){
 test();
 public static void test(){
 //create a Pattern
 Pattern p = Pattern.compile("Bond");
 //create a Matcher and use the Matcher.group() method
 String candidateString = "My name is Bond. James Bond.";
 Matcher matcher = p.matcher(candidateString);
 //extract the group
 matcher.find();
 System.out.println(matcher.group());


public String group(int group)
这个办法供给了强壮而便利的东西,能够得到指定的group所匹配的输入字符串
由于这两个办法常常运用,相同咱们看一个小比如:

import java.util.regex.*;
public class MatcherGroupParamExample{
 public static void main(String args[]){
 test();
 public static void test(){
 //create a Pattern
 Pattern p = Pattern.compile("B(ond)");
 //create a Matcher and use the Matcher.group(int) method
 String candidateString = "My name is Bond. James Bond.";
 //create a helpful index for the sake of output
 Matcher matcher = p.matcher(candidateString);
 //Find group number 0 of the first find
 matcher.find();
 String group_0 = matcher.group(0);
 String group_1 = matcher.group(1);
 System.out.println("Group 0 " + group_0);
 System.out.println("Group 1 " + group_1);
 System.out.println(candidateString);
 //Find group number 1 of the second find
 matcher.find();
 group_0 = matcher.group(0);
 group_1 = matcher.group(1);
 System.out.println("Group 0 " + group_0);
 System.out.println("Group 1 " + group_1);
 System.out.println(candidateString);
public int groupCount() 
这个办法回来了,正则表达式的匹配的组数。 
public boolean matches() 
测验将整个区域与形式匹配。这个要求整个输入字符串都要和正则表达式匹配。 
和find不同, find是会在整个输入字符串查找匹配的子字符串。 
public boolean find() 
find会在整个输入中寻觅是否有匹配的子字符串,一般咱们运用find的流程: 

 

 while(matcher.find()){
 //在匹配的区域,运用group,replace等进行检查和替换操作

public boolean find(int start)
从输入字符串指定的start方位开端查找。

public boolean lookingAt()
基本上是matches更松束缚的一个办法,测验将从区域最初开端的输入序列与该形式匹配

public Matcher appendReplacement (StringBuffer sb, String replacement)
你想把My name is Bond. James Bond. I would like a martini中的Bond换成Smith

StringBuffer sb = new StringBuffer();
String replacement = "Smith";
Pattern pattern = Pattern.compile("Bond");
Matcher matcher =pattern.matcher("My name is Bond. James Bond. I would like a martini.");
while(matcher.find()){
 matcher.appendReplacement(sb,replacement);//成果是My name is Smith. James Smith

Matcher目标会保护追加的方位,所以咱们才干不断地运用appendReplacement来替换一切的匹配。

public StringBuffer appendTail(StringBuffer sb)
这个办法简略的把为匹配的结束追加到StringBuffer中。在上一个比如的最终再加上一句:
matcher.appendTail(sb);
成果就会成为My name is Smith. James Smith. I would like a martini.

public String replaceAll(String replacement)
这个是一个更便利的办法,假如咱们想替换一切的匹配的话,咱们能够简略的运用replaceAll就ok了。
是:

while(matcher.find()){
 matcher.appendReplacement(sb,replacement);//成果是My name is Smith. James Smith
matcher.appendTail(sb);

的更快捷的办法。

public String replaceFirst(String replacement)

这个与replaceAll想对应很简单了解,就是只替换第一个匹配的。

版权声明
本文来源于网络,版权归原作者所有,其内容与观点不代表超凡娱乐立场。转载文章仅为传播更有价值的信息,如采编人员采编有误或者版权原因,请与我们联系,我们核实后立即修改或删除。

猜您喜欢的文章

阅读排行

  • 1

    PHP多态ITeye

    多态,目标,不同
  • 2
  • 3
  • 4

    调用体系程序(转)ITeye

    进程,咱们,程序
  • 5
  • 6

    puttyITeye

    保存,用户名,暗码
  • 7

    1001ITeye

    小数点,个数,位数
  • 8
  • 9
  • 10

    vim装备ITeye

    文件,设置,状况