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两个类。

  

一、使用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 }

 

 

---

 

 

 

二、使用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的静态方法。

 

 

---

 

 

 

数量匹配模式

一、Greedy（贪婪模式）

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

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

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

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

 

 

二、Reluctant（勉强模式）

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

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

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

\w+?　　会优先匹配1次

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

 

 

三、Possessive（占有模式）

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

 

 

---

 

 

 

注意

Java中的正则表达式通常是放在双引号中的，\须要转义。例：

\w　　对应"\\w"

 

只须要转义\，其它预约义的符号，好比？、（）、*等，不用转义。