`

Java正则表达式（二）

正则表达式JavaBlog 
阅读更多
转自http://fuliang.iteye.com/blog/175035
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
下面我们写一个程序来验证一下：
Java代码 复制代码
  1. package edu.jlu.fuliang;   
  2.   
  3. import java.util.regex.Matcher;   
  4. import java.util.regex.Pattern;   
  5.   
  6.   
  7. public class RegexTest {   
  8.     public static void main(String[] args) {   
  9.         String regex = "\\w(\\d\\d)(\\w+)";   
  10.         String candidate = "x99SuperJava";   
  11.            
  12.         Pattern p = Pattern.compile(regex);   
  13.         Matcher matcher = p.matcher(candidate);   
  14.         if(matcher.find()){   
  15.             int gc = matcher.groupCount();   
  16.             for(int i = 0; i <= gc; i++)   
  17.                 System.out.println("group " + i + " :" + matcher.group(i));   
  18.         }   
  19.     }   
  20. }  
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对象。
下面我们看看一个小例子来说明这个结果
Java代码 复制代码
  1. import java.util.regex.*;   
  2.   
  3. public class MatcherPatternExample{   
  4.   public static void main(String args[]){   
  5.       test();   
  6.   }   
  7.   
  8.   public static void test(){   
  9.      Pattern p = Pattern.compile("\\d");   
  10.      Matcher m1 = p.matcher("55");   
  11.      Matcher m2 = p.matcher("fdshfdgdfh");   
  12.   
  13.      System.out.println(m1.pattern() == m2.pattern());   
  14.      //return true   
  15.   }   
  16. }  
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所匹配的字符串在整个字符串的的开始下标：
下面我们看看一个小例子
Java代码 复制代码
  1. public class MatcherStartExample{   
  2.   public static void main(String args[]){   
  3.       test();   
  4.   }   
  5.   public static void test(){   
  6.      //create a Matcher and use the Matcher.start() method   
  7.      String candidateString = "My name is Bond. James Bond.";   
  8.      String matchHelper[] =   
  9.       {"          ^","                      ^"};   
  10.      Pattern p = Pattern.compile("Bond");   
  11.      Matcher matcher = p.matcher(candidateString);   
  12.   
  13.      //Find the starting point of the first 'Bond'   
  14.       matcher.find();   
  15.       int startIndex = matcher.start();   
  16.       System.out.println(candidateString);   
  17.       System.out.println(matchHelper[0] + startIndex);   
  18.   
  19.      //Find the starting point of the second 'Bond'   
  20.       matcher.find();   
  21.       int nextIndex = matcher.start();   
  22.       System.out.println(candidateString);   
  23.       System.out.println(matchHelper[1] + nextIndex);   
  24. }  
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)操作。
看看下面一个小例子：
Java代码 复制代码
  1. import java.util.regex.*;   
  2.   
  3. public class MatcherGroupExample{   
  4.   public static void main(String args[]){   
  5.       test();   
  6.   }   
  7.   public static void test(){   
  8.       //create a Pattern   
  9.       Pattern p = Pattern.compile("Bond");   
  10.   
  11.       //create a Matcher and use the Matcher.group() method   
  12.       String candidateString = "My name is Bond. James Bond.";   
  13.       Matcher matcher = p.matcher(candidateString);   
  14.       //extract the group   
  15.       matcher.find();   
  16.       System.out.println(matcher.group());   
  17.   }   
  18. }  
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所匹配的输入字符串
应为这两个方法经常使用，同样我们看一个小例子：
Java代码 复制代码
  1. import java.util.regex.*;   
  2.   
  3. public class MatcherGroupParamExample{   
  4.   public static void main(String args[]){   
  5.       test();   
  6.   }   
  7.   public static void test(){   
  8.      //create a Pattern   
  9.       Pattern p = Pattern.compile("B(ond)");   
  10.   
  11.      //create a Matcher and use the Matcher.group(int) method   
  12.      String candidateString = "My name is Bond. James Bond.";   
  13.      //create a helpful index for the sake of output   
  14.      Matcher matcher = p.matcher(candidateString);   
  15.      //Find group number 0 of the first find   
  16.       matcher.find();   
  17.       String group_0 = matcher.group(0);   
  18.       String group_1 = matcher.group(1);   
  19.       System.out.println("Group 0 " + group_0);   
  20.       System.out.println("Group 1 " + group_1);   
  21.       System.out.println(candidateString);   
  22.   
  23.      //Find group number 1 of the second find   
  24.       matcher.find();   
  25.       group_0 = matcher.group(0);   
  26.       group_1 = matcher.group(1);   
  27.       System.out.println("Group 0 " + group_0);   
  28.       System.out.println("Group 1 " + group_1);   
  29.       System.out.println(candidateString);   
  30.   }   
  31. }  
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的流程：
Java代码 复制代码
  1. while(matcher.find()){   
  2.    //在匹配的区域，使用group,replace等进行查看和替换操作   
  3. }  
 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
Java代码 复制代码
  1. StringBuffer sb = new StringBuffer();   
  2. String replacement = "Smith";   
  3. Pattern pattern = Pattern.compile("Bond");   
  4. Matcher matcher =pattern.matcher("My name is Bond. James Bond. I would like a martini.");   
  5. while(matcher.find()){   
  6.   matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith   
  7. }  
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了。
是：
Java代码 复制代码
  1. while(matcher.find()){   
  2.   matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith   
  3. }   
  4. matcher.appendTail(sb);  
while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}
matcher.appendTail(sb);

的更便捷的方法。
Java代码 复制代码
  1. public String replaceFirst(String replacement)  
public String replaceFirst(String replacement)

这个与replaceAll想对应很容易理解，就是只替换第一个匹配的。
分享到：
| Java正则表达式（一）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java正则表达式.zip

    Java正则表达式是Java编程语言中用于处理字符串的强大工具，它基于模式匹配的概念，能够高效地进行文本搜索、替换和解析。在Java中，正则表达式主要通过`java.util.regex`包来实现，提供了Pattern和Matcher两个核心...

    Java使用正则表达式提取XML节点内容的方法示例

    为了帮助开发者更好地掌握Java正则表达式技术，我们提供了一系列的Java正则表达式技巧大全，包括《Java正则表达式技巧大全》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧...

    java正则表达式验证IP地址

    Java正则表达式验证IP地址 Java正则表达式验证IP地址是指使用Java语言中的正则表达式来验证IP地址是否符合标准。IP地址是指在网络通信中用来标识设备的地址，它是一种逻辑地址，通过它可以找到网络中的设备。在...

    java正则表达式匹配工具

    Java正则表达式匹配工具是IT领域中一种强大的文本处理工具，它利用正则表达式（Regular Expression）的规则来查找、替换或者提取文本中的特定模式。正则表达式是一种特殊的字符序列，能够帮助程序员或者用户高效地...

    JAVA正则表达式大全

    以下是对这些文档标题所涉及的Java正则表达式知识点的详细解释： 1. **正则表达式之道** 这个主题可能涵盖了正则表达式的基础概念，包括元字符、字符类、量词和分组。元字符如`.`代表任意字符，`^`表示行首，`$`...

    Java正则表达式.ppt

    Java正则表达式是一种强大的文本处理工具，广泛用于验证字符串、查找特定模式和替换文本。在Java中，正则表达式提供了简洁而灵活的方式来处理字符串，使得编程人员能够以更高效的方式实现各种文本操作。 正则表达式...

    Java正则表达式 Java 正则表达式

    Java正则表达式是Java语言中用于处理字符串的强大工具，它允许程序员进行复杂的字符串匹配、查找和替换操作。正则表达式（Regular Expression）是一种模式匹配语言，通过特定的语法来描述字符串的模式，用于在文本中...

    使用Java正则表达式分析处理日志

    本篇将围绕“使用Java正则表达式分析处理日志”这一主题，探讨如何利用Java的正则表达式功能来提取、过滤和操作日志数据。 首先，我们需要理解正则表达式的基本概念。正则表达式（Regular Expression）是一种模式...

    java 正则表达式应用jar包 regex-smart.jar

    Java正则表达式是编程语言Java中的一个强大工具，它用于模式匹配、数据验证和文本检索替换。在Java中，正则表达式是通过java.util.regex包提供的接口和类来实现的。`regex-smart.jar`这个库显然是为了简化开发者在...

    Java 正则表达式 图片版

    Java正则表达式 Java 正则表达式 图片版 携带方便，查阅方便！~

    常用java正则表达式

    ### 常用Java正则表达式知识点 #### 一、引言 正则表达式是一种强大的工具，用于处理文本并查找模式。多种编程语言，包括Perl、PHP、Python、JavaScript以及Java等均内置了对正则表达式的支持。本文将详细介绍Java...

    使用Java正则表达式实现一个简单的身份证号码验证

    #### 二、Java正则表达式简介 Java提供了强大的正则表达式支持，主要通过`java.util.regex`包中的`Pattern`和`Matcher`类来实现。`Pattern`类用于编译正则表达式字符串，而`Matcher`类用于执行与字符串的匹配操作。 ...

    Java正则表达式测试工具

    Java正则表达式测试工具是面向开发者和爱好者的一款实用程序，它可以帮助用户验证和调试他们的正则表达式。在Java编程环境中，正则表达式是一个强大的字符串处理工具，广泛用于数据验证、文本搜索和替换等任务。这款...

    Java 正则表达式库

    Java正则表达式库是Java开发中不可或缺的一部分，它为开发者提供了一种强大的文本匹配工具。在Java中，正则表达式（Regular Expression）是一种模式匹配语言，用于处理字符串操作，如查找、替换或提取特定模式的数据...

    Java正则表达式应用总结

    Java正则表达式是编程语言Java中用于处理字符串和文本的强大工具。它允许开发者通过模式匹配来执行复杂的文本分析和操作。在Java中，正则表达式的操作主要涉及两个核心类：`java.util.regex.Matcher`和`java.util....

    java正则表达式使用例子

    Java正则表达式是Java编程语言中用于处理字符串的强大工具，它允许我们通过模式匹配来查找、替换或分割文本。在Android开发中，正则表达式尤其重要，因为它们可以帮助我们验证用户输入、处理文本数据或者进行复杂的...

    Java正则表达式详细讲解

    Java正则表达式是Java编程语言中用于处理字符串的强大工具，它允许程序员通过模式匹配来查找、替换或分割文本。在Java中，正则表达式是通过`java.util.regex`包提供的API来实现的。本讲解将深入探讨Java正则表达式的...

    Java正则表达式_动力节点Java学院整理

    Java正则表达式详解 Java正则表达式是Java语言中的一种模式匹配技术，用于匹配、查找、替换和判断字符串。它是一种强大的工具，能够帮助开发者快速处理字符串相关的任务。 什么是正则表达式？ 正则表达式是一种...

    Java正则表达式详解(非常适合入门

    #### 二、Java正则表达式的来源与特点 Java正则表达式的语法受到了Perl语言的影响，后者被誉为正则表达式的旗手。尽管Java正则表达式的语法与Perl有相似之处，但也存在差异。具体的不同点可以通过查阅`Pattern`类的...

Magicbox
Global site tag (gtag.js) - Google Analytics