java之正则表达式

正则表达式中的特殊字符 

  \\ 反斜杠 
  \t 间隔 ('\u0009') 
  \n 换行 ('\u000A') 
  \r 回车 ('\u000D') 
  \d 数字等价于[0-9] 
  \D 非数字等价于[^0-9] 
  \s 空白符号 [\t\n\x0B\f\r] 
  \S 非空白符号 [^\t\n\x0B\f\r] 
  \w 单独字符 [a-zA-Z_0-9] 
  \W 非单独字符 [^a-zA-Z_0-9] 
  \f 换页符 
  \e Escape 
  \b 一个单词的边界 
  \B 一个非单词的边界 
  \G 前一个匹配的结束 
  
  ^为限制开头 ^java 条件限制为以Java为开头字符 
  $为限制结尾 java$ 条件限制为以java为结尾字符 
  .为限制一个任意字符 java.. 条件限制为java后除换行外任意两个字符加入特定限制条件 
  
  [a-z] 条件限制在小写a to z范围中一个字符 
  [A-Z] 条件限制在大写A to Z范围中一个字符 
  [a-zA-Z] 条件限制在小写a to z或大写A to Z范围中一个字符 
  [0-9] 条件限制在小写0 to 9范围中一个字符 
  [0-9a-z] 条件限制在小写0 to 9或a to z范围中一个字符 
  [0-9[a-z]] 条件限制在小写0 to 9或a to z范围中一个字符(交集) 
  
  []中加入^后加再次限制条件 
  [^a-z] 条件限制在非小写a to z范围中一个字符 
  [^A-Z] 条件限制在非大写A to Z范围中一个字符 
  [^a-zA-Z] 条件限制在非小写a to z或大写A to Z范围中一个字符 
  [^0-9] 条件限制在非小写0 to 9范围中一个字符 
  [^0-9a-z] 条件限制在非小写0 to 9或a to z范围中一个字符 
  [^0-9[a-z]] 条件限制在非小写0 to 9或a to z范围中一个字符(交集) 

  在限制条件为特定字符出现0次以上时，可以使用「*」 
  J* 0个以上J 
  .* 0个以上任意字符 
  J.*D J与D之间0个以上任意字符 

  在限制条件为特定字符出现1次以上时，可以使用「+」 
  J+ 1个以上J 
  .+ 1个以上任意字符 
  J.+D J与D之间1个以上任意字符 

  在限制条件为特定字符出现有0或1次以上时，可以使用「?」 
  JA? J或者JA 

  出现限制为连续出现指定次数字符「{a}」 
  J{2} JJ 
  J{3} JJJ 

  文字a个以上，并且「{a,}」 
  J{3,} JJJ,JJJJ,JJJJJ,???(3次以上J并存) 

  文字a个以上，b个以下「{a,b}」 
  J{3,5} JJJ或JJJJ或JJJJJ 
  两者取一「|」 
  J|A J或A 
  Java|Hello Java或Hello 

java中解析正则

java.util.regex 是一个用正则表达式所订制的模式来对字符串进行匹配工作的类库包。

它包括两个类： Pattern和 Matcher

Pattern 类

Pattern 的方法如下：

static Pattern	compile(String regex)  将给定的正则表达式编译并赋予给 Pattern 类
static Pattern	compile(String regex, int flags)  同上，但增加 flag 参数的指定，可选的 flag 参数包括：CASE INSENSITIVE,MULTILINE,DOTALL,UNICODE CASE， CANON EQ
int	flags()  返回当前 Pattern 的匹配 flag 参数 .
Matcher	matcher(CharSequence input)  生成一个给定命名的 Matcher 对象
static boolean	matches(String regex, CharSequence input)  编译给定的正则表达式并且对输入的字串以该正则表达式为模开展匹配 , 该方法适合于该正则表达式只会使用一次的情况，也就是只进行一次匹配工作，因为这种情况下并不需要生成一个 Matcher 实例。
String	pattern()  返回该 Patter 对象所编译的正则表达式。
String[]	split(CharSequence input)  将目标字符串按照 Pattern 里所包含的正则表达式为模进行分割。
String[]	split(CharSequence input, int limit)  作用同上，增加参数 limit 目的在于要指定分割的段数，如将 limi 设为 2，那么目标字符串将根据正则表达式分为割为两段。

Matcher 类

Matcher 方法如下：

Matcher	appendReplacement(StringBuffer sb, String replacement)  将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个 StringBuffer 对象里。
StringBuffer	appendTail(StringBuffer sb)  将最后一次匹配工作后剩余的字符串添加到一个 StringBuffer 对象里。
int	end()  返回当前匹配的子串的最后一个字符在原目标字符串中的索引位置 。
int	end(int group)  返回与匹配模式里指定的组相匹配的子串最后一个字符的位置。
boolean	find()  尝试在目标字符串里查找下一个匹配子串。
boolean	find(int start)  重设 Matcher 对象，并且尝试在目标字符串里从指定的位置开始查找下一个匹配的子串。
String	group()  返回当前查找而获得的与组匹配的所有子串内容
String	group(int group)  返回当前查找而获得的与指定的组匹配的子串内容
int	groupCount()  返回当前查找所获得的匹配组的数量。
boolean	lookingAt()  检测目标字符串是否以匹配的子串起始。
boolean	matches()  尝试对整个目标字符展开匹配检测，也就是只有整个目标字符串完全匹配时才返回真值。
Pattern	pattern()  返回该 Matcher 对象的现有匹配模式，也就是对应的 Pattern 对象。
String	replaceAll(String replacement)  将目标字符串里与既有模式相匹配的子串全部替换为指定的字符串。
String	replaceFirst(String replacement)  将目标字符串里第一个与既有模式相匹配的子串替换为指定的字符串。
Matcher	reset()  重设该 Matcher 对象。
Matcher	reset(CharSequence input)  重设该 Matcher 对象并且指定一个新的目标字符串。
int	start()  返回当前查找所获子串的开始字符在原目标字符串中的位置。
int	start(int group)  返回当前查找所获得的和指定组匹配的子串的第一个字符在原目标字符串中的位置。

  「()」中规定一个组合类型比如，我查询<a href=\"index.html\">index</a>中<a href></a>间的数据，可写作<a.*href=\".*\">(.+?)</a> 

在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数： 
Pattern Pattern.compile(String regex, int flag) flag的取值范围如下： 
Pattern.CANON_EQ 当且仅当两个字符的"正规分解(canonical decomposition)"都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式"a\u030A"会匹配"?"。默认情况下，不考虑"规范相等性(canonical equivalence)"。 
Pattern.CASE_INSENSITIVE(?i) 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹配，只要将UNICODE_CASE与这个标志合起来就行了。 
Pattern.COMMENTS(?x) 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(译者注：不是指表达式里的"\\s"，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。 
Pattern.DOTALL(?s) 在这种模式下，表达式'.'可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式'.'不匹配行的结束符。 
Pattern.MULTILINE (?m) 在这种模式下，'^'和'$'分别匹配一行的开始和结束。此外，'^'仍然匹配字符串的开始，'$'也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。 
Pattern.UNICODE_CASE (?u) 在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不敏感的匹配只适用于US-ASCII字符集。 
Pattern.UNIX_LINES(?d) 在这个模式下，只有'\n'才被认作一行的中止，并且与'.'，'^'，以及'$'进行匹配

Java正则用例

◆在字符串包含验证时 

  //查找以Java开头,任意结尾的字符串 
  Pattern pattern = Pattern.compile("^Java.*"); 
  Matcher matcher = pattern.matcher("Java不是人"); 
  boolean b = matcher.matches(); //当条件满足时，将返回true，否则返回false 
  System.out.println(b);

◆分割字符串

import java.util.regex.*; 
 public class Replacement{ 
      public static void main(String[] args) throws Exception { 
        // 生成一个 Pattern, 同时编译一个正则表达式
        Pattern p = Pattern.compile("[/]+"); 
        // 用 Pattern 的 split() 方法把字符串按"/"分割
        String[] result = p.split( 
"Kevin has seen 《 LEON 》 seveal times,because it is a good film."
 +"/ 凯文已经看过《这个杀手不太冷》几次了，因为它是一部"
 +"好电影。/ 名词 : 凯文。"); 
        for (int i=0; i<result.length; i++) 
            System.out.println(result[i]); 
      } 
 }

◆appendReplacement,appendTail使用

// 该例将把句子里的"Kelvin"改为"Kevin"
 import java.util.regex.*; 
 public class MatcherTest{ 
    public static void main(String[] args) 
                         throws Exception { 
        // 生成 Pattern 对象并且编译一个简单的正则表达式"Kelvin"
        Pattern p = Pattern.compile("Kevin"); 
        // 用 Pattern 类的 matcher() 方法生成一个 Matcher 对象
        Matcher m = p.matcher("Kelvin Li and Kelvin Chan are both working in " +
			"Kelvin Chen's KelvinSoftShop company"); 
        StringBuffer sb = new StringBuffer(); 
        int i=0; 
        // 使用 find() 方法查找第一个匹配的对象
        boolean result = m.find(); 
        // 使用循环将句子里所有的 kelvin 找出并替换再将内容加到 sb 里
        while(result) { 
            i++; 
            m.appendReplacement(sb, "Kevin"); 
            System.out.println("第"+i+"次匹配后 sb 的内容是："+sb); 
            // 继续查找下一个匹配对象
            result = m.find(); 
        } 
        // 最后调用 appendTail() 方法将最后一次匹配后的剩余字符串加到 sb 里；
        m.appendTail(sb); 
        System.out.println("调用 m.appendTail(sb) 后 sb 的最终内容是 :"+ 
			sb.toString());
    } 
 }

结果：

最终输出结果为： 
第 1 次匹配后 sb 的内容是：Kevin 
第 2 次匹配后 sb 的内容是：Kevin Li and Kevin 
第 3 次匹配后 sb 的内容是：Kevin Li and Kevin Chan are both working in Kevin 
第 4 次匹配后 sb 的内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's Kevin 
调用 m.appendTail(sb) 后 sb 的最终内容是：Kevin Li and Kevin Chan are both working in Kevin Chen's KevinSoftShop company.

◆group()/group(int group)/groupCount()

import java.util.regex.*; 
 public class GroupTest{ 
    public static void main(String[] args) 
                         throws Exception { 
        Pattern p = Pattern.compile("(ca)(t)");        
        Matcher m = p.matcher("one cat,two cats in the yard"); 
        StringBuffer sb = new StringBuffer(); 
        boolean result = m.find(); 
        System.out.println("该次查找获得匹配组的数量为："+m.groupCount()); 
        for(int i=1;i<=m.groupCount();i++){ 
         System.out.println("第"+i+"组的子串内容为： "+m.group(i)); 
        } 
    } 
 }

结果：

该次查找获得匹配组的数量为：2 
第 1 组的子串内容为：ca 
第 2 组的子串内容为：t

◆以多条件分割字符串时 

 Pattern pattern = Pattern.compile("[, |]+"); 
  String[] strs = pattern.split("Java Hello World Java,Hello,,World|Sun"); 
  for (int i=0;i<strs.length;i++) { 
    System.out.println(strs[i]); 
  }

◆文字替换（首次出现字符） 

  Pattern pattern = Pattern.compile("正则表达式"); 
  Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World"); //替换第一个符合正则的数据
  System.out.println(matcher.replaceFirst("Java"));

◆文字替换（全部）

  Pattern pattern = Pattern.compile("正则表达式");
  Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World"); //替换第全部符合正则的数据
  System.out.println(matcher.replaceAll("Java"));

◆文字替换（置换字符）

Pattern pattern = Pattern.compile("正则表达式"); 
  Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World "); 
  StringBuffer sbr = new StringBuffer(); 
  while (matcher.find()) { 
    matcher.appendReplacement(sbr, "Java"); 
  }
  matcher.appendTail(sbr); 
  System.out.println(sbr.toString()); 

◆验证是否为邮箱地址 

  String str="ceponline@yahoo.com.cn"; 
  Pattern pattern = Pattern.compile("[\\w\\.\\-]+@([\\w\\-]+\\.)+[\\w\\-]+",Pattern.CASE_INSENSITIVE); 
  Matcher matcher = pattern.matcher(str); 
  System.out.println(matcher.matches()); 

◆去除html标记 

Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL); 
Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>"); 
String string = matcher.replaceAll(""); 
System.out.println(string);

◆查找html中对应条件字符串 

Pattern pattern = Pattern.compile("href=\"(.+?)\""); 
Matcher matcher = pattern.matcher("<a href=\"index.html\">主页</a>"); 
if(matcher.find()) { 
	System.out.println(matcher.group(1)); 
}

◆截取http://地址//截取url 

Pattern pattern = Pattern.compile("(http://|https://){1}[\\w\\.\\-/:]+"); 
Matcher matcher = pattern.matcher("dsdsds<http://dsds//gfgffdfd>fdf"); 
StringBuffer buffer = new StringBuffer(); 
while(matcher.find()){ 
	buffer.append(matcher.group()); 
	buffer.append("\r\n");
	System.out.println(buffer.toString()); 
}

◆替换指定{}中文字 

String str = "Java目前的发展史是由{0}年-{1}年"; 
String[][] object={new String[]{"\\{0\\}","1995"},new String[]{"\\{1\\}","2007"}}; 
System.out.println(replace(str,object)); 
public static String replace(final String sourceString,Object[] object) { 
	String temp=sourceString; 
	for(int i=0;i<object.length;i++) { 
	    String[] result = (String[]) object[i]; 
	    Pattern pattern = Pattern.compile(result[0]); 
	    Matcher matcher = pattern.matcher(temp); 
	    temp = matcher.replaceAll(result[1]); 
	} 
	return temp; 
}