学步园

package com.metarnet.Execution.util;
import java.io.UnsupportedEncodingException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * String正则表达式匹配
 * 闫帆
 */
public class StringUtil {
/**
* 函数名：strToInt 作 用：把字符串转为整型 参 数：s: 字符串型 返回值：整型
**/
public static int strToInt(String s) {
int i = 0;
try {
i = Integer.parseInt(s);
} catch (NumberFormatException illl) {
i = 0;
}
return i;
}

/**
* 函数名：strToInt 作 用：把字符串转为整型 参 数：s: 字符串型 参 数：itt: 整型 返回值：整型 如果返回值为‘0’则返回
* itt;
**/
public static int strToInt(String s, int itt) {
int i = strToInt(s);
if (i == 0)
i = itt;
return i;
}

public static  String encode(String result, String code) {
String res = null;
try {
res = new String(result.getBytes(), code);
} catch (UnsupportedEncodingException ex) {
System.out.println("charset:" + ex.getMessage());
res = result;
}
return res;
}

/**
* 正则表达式匹配,返回匹配成功的次数
* 
* @param str
*            原字符串
* @param regEx
*            正则表达式
* @return 返回匹配成功的次数
*/
public static int findReturnCount(String str, String regEx) {
int count = 0;
Pattern p = Pattern.compile(regEx);
Matcher matcher = p.matcher(str);
while (matcher.find()) {
count++;
}
return count;
}

/**
* 正则表达式匹配,只要匹配成功一次，则返回true
* 
* @param str
*            原字符串
* @param regEx
*            正则表达式
* @return 只要匹配成功一次，则返回true
*/
public static boolean findReturn(String str, String regEx) {
boolean flag = false;
String[] regExs = regEx.split("\\|");
for (String regExStr : regExs) {
Pattern p = Pattern.compile(regExStr);
Matcher matcher = p.matcher(str);
if (matcher.find()) {
flag = true;
return flag;
}
}
return false;
}

/**
* 正则表达式分割字符串
* 
* @param str
*            原字符串
* @param regEx
*            正则表达式
* @param child
*            子匹配,0匹配整个表达式,1匹配第一个括号内的表达式...
* @return 返回分割后的字符串数组
*/
public static String[] splitStr(String str, String regEx, int child) {
Pattern p = Pattern.compile(regEx);
String formatStr = "";
Matcher matcher = p.matcher(str);
while (matcher.find()) {
formatStr += matcher.group(child) + "`";
}
if (formatStr.equals("")) {
return str.split("\\`");
}
return formatStr.split("\\`");
}

/**
* 正则表达式分割字符串
* 
* @param str
*            原字符串
* @param regEx
*            正则表达式
* @param child
*            子匹配,0匹配整个表达式,1匹配第一个括号内的表达式...
* @param column
*            分割后字符串数组的长度
* @return 返回分割后字符串数组的长度等于column的行的字符串数组
*/
public static String[] splitStr(String str, String regEx, int column,
int child) {
Pattern p = Pattern.compile(regEx);
String formatStr = "";
Matcher matcher = p.matcher(str);
while (matcher.find()) {
formatStr += matcher.group(child) + "`";
}
if (formatStr.equals("")) {
return str.split("\\`");
}
return formatStr.split("\\`");
}
}




例：判断一个字符串是否是以END结尾（结尾可存在特殊字符，不能存在字母数字和汉字）

        String returnString="asd fsadf   " +
"asdfasdfasd  fasdfa" +
"sdf  asdsdc" +
"asdfa  sdfa" +
"dfasd   fcsd" +
"casd  ascsdfEND";
String parse="([\\s\\S]*?)END\\W*$";
System.out.println(StringUtil.findReturn(returnString, parse));

判断一个字符串是否是以END开头和结尾（开头结尾可存在特殊字符，不能存在字母数字和汉字）
public static void main(String[] args) {
String returnString="<ENDasd fsadf   " +
"asdfasdfasd  fasdfa" +
"sdf  asdsdc" +
"asdfa  sdfa" +
"dfasd   fcsd" +
"casd  ascsdfEND>";
String parse="^\\W*END([\\s\\S]*?)END\\W*$";
System.out.println(StringUtil.findReturn(returnString, parse));
}

判断一个字符串是否是以END开头和结尾（开头不能存在任何字符，结尾可存在特殊字符，不能存在字母数字和汉字）
public static void main(String[] args) {
String returnString="ENDasd fsadf   " +
"asdfasdfasd  fasdfa" +
"sdf  asdsdc" +
"asdfa  sdfa" +
"dfasd   fcsd" +
"casd  ascsdfEND";
String parse="^END([\\s\\S]*?)END\\W*$";
System.out.println(StringUtil.findReturn(returnString, parse));
}


判断一个字符串是否是以END开头和结尾（开头和结尾都不能存在任意字符）
public static void main(String[] args) {
String returnString="ENDasd fsadf   " +
"asdfasdfasd  fasdfa" +
"sdf  asdsdc" +
"asdfa  sdfa" +
"dfasd   fcsd" +
"casd  ascsdfEND";
String parse="^END([\\s\\S]*?)END$";
System.out.println(StringUtil.findReturn(returnString, parse));
}

-----------------------------------程序员 闫帆原创---------------------------------------

转载请注明原创人信息  程序员 闫帆yanfanvip