java中使用正则表达式

package com.puckasoft.regex;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TestRegex {
/**
  * 验证传入的字符串是否整个匹配正表达式
  * @param regex: 正则表达式
  * @param decStr：要匹配的字符串
  * @return ：若匹配，则返回true;否则，返回false;
  */
public static boolean validate(String regex, String decStr) {
  // 表达式对象
  Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);   //
  // 创建 Matcher 对象
  Matcher m = p.matcher(decStr);  
  // 是否完全匹配
  boolean yesorno = m.matches();   //该方法尝试将整个输入序列与该模式匹配
  return yesorno;
} /**
  * 给定字符串中是否有符合给定正则表达式的子字符串，返回匹配的子字符串
  * @param regex：正则表达式
  * @param decStr：要匹配的字符串
  * @return :返回匹配的第一个字符串，若不匹配则null
  */
public static String search(String regex, String decStr) {
  // 表达式对象
  Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
  // 创建 Matcher 对象
  Matcher m = p.matcher(decStr);  
  // 是否找到匹配
  boolean found = m.find();  //该方法扫描输入序列以查找与该模式匹配的下一个子序列。
   String foundstring="";
  if(found){
      foundstring = m.group();
      String foundstring1 = m.group(0);  //group(),group(0)返回符合整个表达式的子字符串
      String foundstring2 = m.group(1);  //group(1)返回符合整个表达式的子字符串中匹配第一个表达式的子字符串
      String foundstring3 = m.group(2); //group(2)返回符合整个表达式的子字符串中匹配第一个表达式的子字符串
      int    beginPos    = m.start();
      int    endPos      = m.end();
      System.out.println("group():"+foundstring);
      System.out.println("group(0):"+foundstring1);
      System.out.println("group(1):"+foundstring2);
      System.out.println("group(2):"+foundstring3);
      System.out.println("beginPos:"+beginPos);
      System.out.println("endPos"+endPos);
  }
  
  return foundstring;
} /**
  * 返回给定字符串中匹配给定正则表达式所有子字符串
  * @param regex
  * @param decStr
  * @return List：返回所有匹配正则表达式的子字符串
  */
public static List searchSubStr(String regex,String decStr) {
  // 表达式对象
  Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
  // 创建 Matcher 对象
  Matcher m = p.matcher(decStr);  
  
  int i=0;
  List list = new ArrayList();
  while(m.find(i)){
   list.add(m.group());
   i= m.end();
  }
  
  return list;
//  for(int j=0;j<list.size();j++) {
//   System.out.println((String)list.get(j));
//  } } /**
  * 替换给定字符串中匹配正则表达式的子字符串
  * @param regex：正则表达式
  * @param decStr：所要匹配的字符串
  * @param replaceStr：将符合正则表达式的子串替换为该字符串
  * @return：返回替换以后新的字符串
  */
public static String replace(String regex,String decStr,String replaceStr) {
  // 表达式对象
  Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
  // 创建 Matcher 对象
  Matcher m = p.matcher(decStr);
  
  // 替换
  String newstring = m.replaceAll(replaceStr);
//  System.out.println(newstring);
  return newstring;
} public static void testSplit() {
  String str = "abc5Adefghi7Ajklmn";
  // 分割
  String [] strs = str.split("([url=file://\\d)(A]\\d)(A[/url])");
  for(int i=0;i<strs.length;i++) {
   System.out.println(strs);
  }
}
public static void main(String[] args) {
  String regex = "([url=file://\\d{2})([a-c]{2})([e-g]{2]\\d{2})([a-c]{2})([e-g]{2[/url]})";
  String decStr = "dsfdfsfds22bbff   33ccgg 11bbee sdfdsfdsfds"; //dsfdfsfds*   * * sdfdsfdsfds
//  System.out.println(TestRegex.validate(regex, decStr));
//  System.out.println(TestRegex.search(regex, decStr));
  
//  List list = TestRegex.searchSubStr(regex, decStr);
//  for(int i=0;i<list.size();i++) {
//   System.out.println(list.get(i));
//  }
  
//  System.out.println(TestRegex.replace(regex, decStr, "*"));
  
  TestRegex.testSplit();
  
}