Java 正则表达式的使用

正则表达式是一个用于匹配字符串的模板，用于匹配字符串。

正则表达式语法

  .　　小数点，可匹配\n之外的任何一个字符，要匹配小数点，用\.

x　　x是某一具体字符，表示匹配该字符

\d　　匹配0-9之间的一个数字

\D　　匹配\d之外的任一个字符

\s　　匹配任一个空白，包括空格、制表符、回车符、换行符

\S　　匹配\s之外的任一个字符

\w　　匹配任一个单词字符，包括数字0-9，英文字母大写26个、小写26个，下划线_

\W　　匹配\w之外的任一个字符

\t　　制表符

\n　　换行符

\r　　回车符

以上式子均只匹配一个字符

\　　表示匹配一个正则表达式中的预定义符号，例：\\匹配一个\， \(匹配一个（，   \?匹配一个？

|　　表示2项中选择一项，相当于“或”。例：ab|c表示匹配ac或bc，（ab)|[a-d]表示匹配ab或a-d之间的任一个字符，ab|cd|e表示匹配abd、abe、acd、ace中的任一个。

()     表示一个子表达式，将此子表达式作为一个整体来看。要匹配（），用\(    \)

中括号：

[]　　表示匹配指定范围中的任一个字符，例：[abc]表示匹配a、b、c中的任一个字符。

-　　表示范围，例：[!a-z]表示匹配!、所有小写字母中的任一个字符

^　　表示非，例：[^abc]表示匹配a、b、c之外的任一个字符，[^a-d]表示匹配a、b、c、d之外的任一个字符。要把后面部分当成一个整体来看

&&　　表示取交集，例：[a-d&&c-z]相当于[cd]，匹配c，d中的任一个字符

中括号只匹配一个字符。要匹配[] ，使用\[　　\]

数量限定

*　　0次及以上。匹配*请用\*

+　　1次及以上。匹配+请用\+

?　　0次或1次

{m}     m次

{m,}　　至少m次

{m,n}　　至少m次，至多n次。

以上均表示前一个字符、（子）表达式出现的次数

位置限定

^　　行的开头，放在该部分前面，例：^H   表示匹配H，H要是一行的开头

$　　行的结尾，放在该部分的后面，例：。$      表示匹配。   。要是一行的结尾

\b　　单词的边界，前边界就放在该部分的前面，后边界就放在该部分的后面，例：\bH  表示匹配H，H要是某个单词的开头；H\b表示匹配H，H要是某个单词的结尾。

\B　　不是单词的边界。不是前边界就放在该部分的前面，不是后边界就放在该部分的后面，例：\BH  表示匹配H，H不是某个单词的开头；H\B表示匹配H，H不是某个单词的结尾。

以上均是对一个字符、（子）表达式位置的说明。

使用正则表达式有两种方式：

• 使用String类的方法
• 使用Pattern+Matcher两个类。

1、使用String类的方法：

boolean  matches(String  regex)    该串中是否有匹配。此方法是整串匹配，即该串整个是regex的一个匹配才返回true。比如"hello".matches("hello")返回true，"hello".matches("he")返回false。

String  replaceFirst(String regex,String replacement)　　替换第一个匹配，返回替换后的串。若无匹配，则返回原串。

String  replaceAll(String regex,String replacement)     替换所有的匹配，返回替换后的串。若无匹配，则返回原串。

String[]  split(String regex)    以regex作为分隔符，把该串分割成多个子串

String  Arrays.toString(String[]  arr)    将String[]连接成一个字符串并返回。静态方法。

示例：

 1 package test;
 2 
 3 public class Test{
 4        public static void main(String[] args){
 5               String str="hello world!";
 6               System.out.println(str.replaceFirst("h","H"));    //Hello world!
 7               //正则表达式是\w，但放在""内，\要转义为\\
 8               System.out.println(str.replaceFirst("\\w","H"));    //Hello world!
 9        }
10 }

2、使用Pattern+Matcher两个类

Pattern对象是正则表达式编译后在内存中的表示形式，需要先调用Pattern类的静态方法compile(String regex)将正则表达式编译为Pattern对象：

Pattern  p=Pattern.compile("\\w");       //参数为正则表达式

再使用Pattern对象的matcher(String str)获取Matcher对象：

Matcher  m=p.matcher("hello world!");      //参数为字符串（用上面的regex匹配这个字符串）

之后就可以用Matcher对象的方法来匹配该串：

boolean   b=m.matches();       //是否有匹配，这个方法是整串匹配。注意上面是er，这里是es。

boolean  b=m.find();      //是否有匹配，该串中有匹配就返回true。

String  str=m.replaceFirst(String replacement);     //用指定字符串替换第一个匹配，返回替换后的串

String  str=m.replaceAll(String replacement);     //用指定字符串替换所有匹配，返回替换后的串

示例：

 1 package test;
 2 
 3 import java.util.regex.Matcher;
 4 import java.util.regex.Pattern;
 5 
 6 public class Test{
 7        public static void main(String[] args){
 8               Pattern p=Pattern.compile("\\bhe");
 9               Matcher m=p.matcher("hello world!");
10               System.out.println(m.find());   //true
11               System.out.println(m.matches());   //false
12               System.out.println(m.replaceFirst("He"));   //Hello world!
13               System.out.println(m.replaceAll("He"));   //Hello world!
14        }
15 }

上面的Pattern对象可以重复使用，就是说可以直接使用这个正则表达式去匹配其它的字符串。

如果某个正则表达式只需要使用一次，可以这样：

Boolean  b=Pattern.matches(String regex,String str);      //会把regex编译成匿名的Pattern对象，并执行匹配

注意：只有matches()方法可以这样用。mathces()是Pattern的静态方法。

数量匹配模式

1、Greedy（贪婪模式）

数量表示符默认使用贪婪模式匹配，尽可能多的匹配字符，除非明确使用其它匹配模式。例：

\w{2,5}   　　会尽可能多的匹配，能匹配5个就匹配5个，不行就4个，再不行就3个........     

 \w?   　　？表示匹配0次或1次，会优先匹配1次，没有才匹配0次。

\w+　　  +表示匹配1次及以上，优先匹配最多次。

2、Reluctant（勉强模式）

尽可能少的匹配字符，也称最小匹配模式。需要在数量表示符后用一个额外的？来说明该部分使用最小匹配模式。例：

\w{2,5}?\w　  \w{2,5}?会优先匹配2个

\w??\w        \w?会优先匹配0个

\w+?　　会优先匹配1次

？要放在数量表示符后面，才表示前面该部分采用   最小匹配模式。如果?之前无数量表示符，则？表示匹配0个或1个，会采用贪婪模式。

3、Possessive（占有模式）

在数量表示符后面用一个额外的+来说明该部分使用占有模式，不常用。

注意

Java中的正则表达式一般是放在双引号中的，\需要转义。例：

\w　　对应"\\w"

只需要转义\，其它预定义的符号，比如？、（）、*等，不用转义。