Java.io包教程

Java - 正则表达式

Java提供了java.util.regex包,用于与正则表达式进行模式匹配. Java正则表达式与Perl编程语言非常相似,非常容易学习.

正则表达式是一个特殊的字符序列,可以帮助您匹配或查找其他字符串或字符串集,使用模式中保存的专用语法.它们可用于搜索,编辑或操作文本和数据.

java.util.regex包主要由以下三个类组成 :

  • 模式类 :  Pattern对象是正则表达式的编译表示. Pattern类不提供公共构造函数.要创建模式,必须首先调用其公共static compile()方法之一,然后返回Pattern对象.这些方法接受正则表达式作为第一个参数.

  • 匹配类 :  Matcher对象是解释模式并对输入字符串执行匹配操作的引擎.与Pattern类一样,Matcher也没有定义公共构造函数.通过在Pattern对象上调用 matcher()方法获取Matcher对象.

  • PatternSyntaxException &减去; PatternSyntaxException对象是未经检查的异常,表示正则表达式模式中的语法错误.

捕获组

捕获组是将多个字符视为一个单元的一种方法.它们是通过将要分组的字符放在一组括号中来创建的.例如,正则表达式(dog)创建一个包含字母"d","o"和"g"的组.

捕获组的编号通过计算它们的左括号来计算从左到右.在表达式((A)(B(C)))中,例如,有四个这样的组 :

  • (( A)(B(C)))

  • (A)

  • (B(C))

  • (C)

要查明表达式中存在多少个组,请在匹配器对象上调用groupCount方法. groupCount方法返回 int ,显示匹配器模式中存在的捕获组数.

还有一个特殊组,组0,它始终代表整个表达.此组不包含在groupCount报告的总数中.

示例

以下示例说明了如何查找数字来自给定字母数字字符串的字符串 :

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

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

这将产生以下结果 :

输出

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

正则表达式语法

下面是列出Java和minus中可用的所有正则表达式元字符语法的表;

Subexpression匹配
^匹配行的开头.
$匹配行尾.
           .匹配除换行符之外的任何单个字符.使用 m 选项也可以匹配换行符.
[...]匹配括号中的任何单个字符.
[^ ...]匹配括号内的任何单个字符.
\A整个字符串的开头.
\ z整个字符串的结尾.
          \ Z整个结束除允许的最终行终止符之外的字符串.
         re *匹配前面表达式的0次或多次出现.
re+匹配前一个或多个.
re?匹配前面表达式的0或1次出现.
       re {n}完全匹配前面表达式的n次出现次数.
      re {n,}匹配前面表达式的n次或多次出现.
    re {n,m}匹配前面表达式中至少n次和最多m次出现.
a | b匹配a或b.
       ( re)分组正则表达式并记住匹配的文本.
       (?:re)在不记住匹配文本的情况下对正则表达式进行分组.
(?> re)匹配独立模式而不回溯.
\ w匹配单词字符.
\ W匹配非单词字符.
\ s匹配空白.相当于[\\\\\\\\].
\S匹配非空白.
          \d匹配数字.相当于[0-9].
\ D匹配非数字.
\ A匹配字符串的开头.
          \Z匹配字符串的结尾.如果存在换行符,则它在换行符之前匹配.
\ z匹配字符串的结尾.
\ G匹配最后一场比赛结束的点.
\ n对捕获组号"n"的反向引用.
         \ b在括号外部匹配单词边界.在括号内匹配退格(0x08).
\ B匹配非单词边界.
\ n,\t等.匹配换行符,回车符,制表符等.
\ Q转义(引用)所有字符到\ E.
\ E结束以\\开头的报价\\ Q.

匹配类的方法

这是一个列表有用的实例方法 :

索引方法

索引方法提供了有用的索引值,可以准确显示在输入字符串中找到匹配的位置 :

Sr.No.方法&说明
1

public int start()

返回上一场比赛的开始索引.

2

public int start(int group)

返回上一个匹配操作期间给定组捕获的子序列的起始索引.

3

public int end()

返回之后的偏移量最后一个字符匹配.

4

public int end(int group)

返回上一个匹配操作期间给定组捕获的子序列的最后一个字符之后的偏移量.

学习方法

学习方法检查输入字符串并返回一个布尔值,指示是否找到该模式;

Sr.No.方法&说明
1

public boolean lookingAt()

尝试将区域开头的输入序列与模式匹配.

2

public boolean find()

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

3

public boolean find(int start)

重置此匹配器,然后尝试从指定的索引处开始查找与模式匹配的输入序列的下一个子序列.

4

public boolean matches()

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

替换方法

替换方法是r的有用方法在输入字符串中替换文字 :

Sr.No.方法&说明
1

public Matcher appendReplacement(StringBuffer sb,String replacement)

实现非终端追加和替换步骤.

2

public StringBuffer appendTail(StringBuffer sb )

实现终端追加和替换步骤.

3

public String replaceAll(String replacement)

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

4

public String replaceFirst(String replacement)

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

5

public static String quoteReplacement(String s)

返回指定String的文字替换String.此方法生成一个String,它将作为Matcher类的appendReplacement方法中的文字替换 s .

开始和结束方法

以下是计算单词"cat"出现在输入字符串中的次数的示例 :

示例

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

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      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());
      }
   }
}

这将产生以下结果 :

输出

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

你可以看到这个示例使用单词边界来确保字母"c""a""t"不仅仅是较长单词中的子字符串.它还提供了一些有关输入字符串匹配发生位置的有用信息.

start方法返回上一个匹配操作期间给定组捕获的子序列的起始索引,以及end返回匹配的最后一个字符的索引加一.

匹配和查找方法

匹配和lookingAt方法都尝试匹配针对模式的输入序列.然而,不同之处在于匹配需要匹配整个输入序列,而lookingAt则不匹配.

两种方法总是从输入字符串的开头开始.以下是解释功能和减号的示例;

示例

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

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

这将产生以下结果 :

输出

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst和replaceAll方法

replaceFirst和replaceAll方法替换文本匹配给定的正则表达式.正如其名称所示,replaceFirst替换第一次出现,replaceAll替换所有出现次数.

以下是解释功能的示例 :

示例

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

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

这将产生以下结果 :

输出

The cat says meow. All cats say meow.

appendReplacement和appendTail方法

Matcher类还提供了appendReplacement和appendTail方法来替换文本.

以下是解释功能和减号的示例;

示例

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

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

这将产生以下结果 :

输出

-foo-foo-foo-

PatternSyntaxException类方法

PatternSyntaxException是一个未经检查的异常,表示正则表达式模式中的语法错误. PatternSyntaxException类提供以下方法来帮助您确定出错和减去的内容;

Sr .No.方法&说明
1

public String getDescription()

检索错误的描述.

2

public int getIndex()

检索错误索引.

3

public String getPattern()

检索错误的正则表达式模式.

4

public String getMessage()

返回一个多行字符串,其中包含语法错误及其索引的描述,错误的正则表达式模式以及错误的可视指示模式中的索引.