频道栏目
首页 > 资讯 > Java > 正文

java正则表达式处理类

12-08-31        来源:[db:作者]  
收藏   我要投稿

[java] 
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)); 

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));
}


 

相关TAG标签
上一篇:Mybatis - Mapper文件简练
下一篇:Android自动聚焦、摄像头拍照、缩放至标准大小的完整实现
相关文章
图文推荐

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站