public class StringUtils extends org.apache.commons.lang3.StringUtils {
/**
* 格式化字符串
*
* 例：formateString("xxx{0}bbb",1) = xxx1bbb
*
* @param str
* @param params
* @return
*/
public static String formateString(String str, String... params) {
for (int i = 0; i < params.length; i++) {
str = str.replace("{" + i + "}", params[i] == null ? "" : params[i]);
}
return str;
}
/**
* 判别字符串是否为null或者没有内容
*
* @param inStr
* 被判断的输入参数
* @return 布尔值：true=表示输入字符串为null或者没有内容 false=表示输入字符串不为null或者有内容
*/
public static boolean zero(String inStr) {
return ((null == inStr) || (inStr.length() <= 0));
}
/**
* 判断字符串是否为null或没有内容或全部为空格。
*
* @param inStr
* 被判断的输入参数
* @return 布尔值：true=表示输入字符串为null或没有内容或全部为空格 false=表示输入字符串不为null或有内容或全部不为空格
*/
public static boolean empty(String inStr) {
return (zero(inStr) || (inStr.trim().equals("")));
}
/**
* 判断字符串是否为null或没有内容或全部为空格。
* @param inStr 被判断的输入参数
* @return inStr 如果为空则返回null 否则返回原值
*/
public static String stringIsNull(String inStr) {
if (empty(inStr))
return inStr;
return null;
}
/**
* 对象是否为空
*
* @param data
* @return 布尔值：true=表示输入对象为null
*/
public static boolean isEmpty(Object data) {
if (data == null || "".equals(data) || data.equals("null")) {
return true;
}
else {
return false;
}
}
/**
* 判断字符串是否为null或没有内容或全部为空格或者为undefined。
*
* @param inStr
* 被判断的输入参数
* @return 布尔值：true=表示输入字符串为null或没有内容或全部为空格 false=表示输入字符串不为null或有内容或全部不为空格
*/
public static boolean emptyorundefined(String inStr) {
return (zero(inStr) || (inStr.trim().equals("")) || (inStr.trim().equals("undefined") || inStr.trim().equals(
"null")));
}
/**
* 在str为null或者没有内容的情况下，返回空串；否则返回输入参数。
*
* @param inStr
* 被判断的输入参数
* @return 字符串="" 表示输入字符串为null或者没有内容 字符串!="" 表示输入字符串有内容
*/
public static String toZeroSafe(String inStr) {
if (zero(inStr)) {
return "";
}
return inStr;
}
/**
* 在inStr为null或者没有内容的情况下，返回def；否则返回str
*
* @param inStr
* 被判断的输入参数
* @param def
* inStr为null或者没有内容的情况下，需要返回的字符串
* @return 字符串=def 表示输入字符串为null或者没有内容 字符串=inStr 表示输入字符串有内容
*/
public static String toZeroSafe(String inStr, String def) {
if (zero(inStr)) {
return def;
}
return inStr;
}
/**
* 在str为null或者没有内容，或者全部为空格的情况下，返回空串；否则返回str
*
* @param inStr
* 被判断的输入参数
* @return 字符串="" 表示输入字符串为null或者没有内容或者全部为空格 字符串!="" 表示输入字符串有内容
*/
public static String toEmptySafe(String inStr) {
if (empty(inStr)) {
return "";
}
return inStr;
}
/**
* 在str为null或者没有内容，或者全部为空格的情况下，返回def；否则返回str
*
* @param inStr
* 被判断的输入参数
* @param def
* inStr为null或者没有内容或者全部为空格的情况下，需要返回的字符串
* @return 字符串=def 表示输入字符串为null或者没有内容或者全部为空格 字符串=inStr 表示输入字符串有内容
*/
public static String toEmptySafe(String inStr, String def) {
if (empty(inStr)) {
return def;
}
return inStr;
}
/**
* 去掉输入字符串首尾空格
*
* @param inStr
* 输入字符串
* @return 首尾无空格的字符串
*/
public static String trim(String inStr) {
if (empty(inStr)) {
return inStr;
}
return inStr.trim();
}
/**
* 判断字符串是否内容相同
*
* @param s1
* 第1个输入字符串
* @param s2
* 第2个输入字符串
* @return 布尔值=true：两个字符串相等 =false:两个字符串不相等
*/
public static boolean equals(String s1, String s2) {
if (s1 == s2)
return true;
if (null == s1)
return false;
return s1.equals(s2);
}
/**
* 判断字符串是否内容相同，不区分大小写
*
* @param s1
* 第1个输入字符串
* @param s2
* 第2个输入字符串
* @return 布尔值=true：两个字符串相等 =false:两个字符串不相等
*/
public static boolean equalsIgnoreCase(String s1, String s2) {
if (null == s1) {
return false;
}
return s1.equalsIgnoreCase(s2);
}
/**
* 把字符数组转换成字符串
*
* @param array
* 字符数组
* @return 转换后的字符串
*/
public static String toString(char[] array) {
return String.valueOf(array);
}
/**
* 在str字符串中，将所有token字符串，用delim字符串进行转义处理。
*
* @param str
* 被替换的字符串
* @param token
* 被替换的子字符串
* @param delim
* 子字符串需要替换的内容
* @return 已经替换好的字符串
*/
public static String normalize(String str, String token, String delim) {
// 为空，直接返回
if (empty(str)) {
return "";
}
// 查找并替换
StringTokenizer tokenizer = new StringTokenizer(str, token);
StringBuilder fixedBuilder = new StringBuilder();
while (tokenizer.hasMoreTokens()) {
if (fixedBuilder.length() == 0) {
fixedBuilder.append(tokenizer.nextToken());
}
else {
fixedBuilder.append(fixedBuilder);
fixedBuilder.append(delim);
fixedBuilder.append(token);
fixedBuilder.append(tokenizer.nextToken());
}
}
if (str.indexOf(delim) == 0) {
fixedBuilder.append(delim).append(token).append(fixedBuilder);
}
if (str.lastIndexOf(delim) == (str.length() - 1)) {
fixedBuilder.append(fixedBuilder).append(delim).append(token);
}
return fixedBuilder.toString();
}
/**
* 在字符串中，用新的字符串替换指定的字符
*
* @param src
* 需要替换的字符串
* @param charOld
* 被替换的字符
* @param strNew
* 用于替换的字符串
* @return 已经替换好的字符串
*/
public static String replace(String src, char charOld, String strNew) {
if (null == src) {
return src;
}
if (null == strNew) {
return src;
}
StringBuilder buf = new StringBuilder();
for (int i = 0, n = src.length(); i < n; i++) {
char c = src.charAt(i);
if (c == charOld) {
buf.append(strNew);
}
else {
buf.append(c);
}
}
return buf.toString();
}
/**
* 把字符串的第一个字符变为大写
*
* @param s
* 输入字符串
* @return 返回第一个字符是大写的字符串
*/
public static String upperFirst(String s) {
String str = null;
if (null != s) {
if (s.length() == 1) {
str = s.toUpperCase();
}
else {
str = s.substring(0, 1).toUpperCase() + s.substring(1);
}
}
return str;
}
/**
* 把字符对象第一个字符变为大写
*
* @param sb
* 字符对象
*/
public static void upperFirst(StringBuilder sb) {
if ((null != sb) && (sb.length() > 0)) {
sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
}
}
/**
* 把字符串的第一个字符变为小写
*
* @param s
* 输入的字符串
* @return 返回的第一个字符是小写的字符串
*/
public static String lowerFirst(String s) {
String str = null;
if (null != s) {
if (s.length() == 1) {
str = s.toLowerCase();
}
else {
str = s.substring(0, 1).toLowerCase() + s.substring(1);
}
}
return str;
}
/**
* 把字符对象的第一个字符变为小写
*
* @param sb
* 输入的字符对象
*/
public static void lowerFirst(StringBuilder sb) {
if ((null != sb) && (sb.length() > 0)) {
sb.setCharAt(0, Character.toLowerCase(sb.charAt(0)));
}
}
/**
* 根据指定的delima标志获取输入字符串的后缀
*
* @param str
* 输入字符串
* @param delima
* 指定的标志,一般是一个字符，如“.”
* @return 输入字符串子的后缀
*/
public static String getLastSuffix(String str, String delima) {
if (zero(delima)) {
return str;
}
String suffix = "";
if (!zero(str)) {
int index = str.lastIndexOf(delima);
if (index >= 0) {
suffix = str.substring(index + delima.length());
}
else {
suffix = str;
}
}
return suffix;
}
/**
* 根据指定的delima标志获取输入字符串的前缀
*
* @param src
* 输入字符串
* @param delima
* 指定的标志,一般是一个字符，如“.”
* @return 输入字符串的前缀
*/
public static String getLastPrefix(String src, String delima) {
if (zero(delima)) {
return src;
}
String prefix = "";
if (!zero(src)) {
int index = src.lastIndexOf(delima);
if (index >= 0) {
prefix = src.substring(0, index);
}
}
return prefix;
}
/**
* 判断输入字符串是否包含指定的字符串 ""空串不认为被包含。String.indexOf()认为空串被包含
*
* @param str
* 输入字符串
* @param searchStr
* 指定是否包含的字符串
* @return =true:包含指定的字符串 =false:不包含指定的字符串
*/
public static boolean contains(String str, String searchStr) {
if (str == null || searchStr == null) {
return false;
}
if (searchStr.length() == 0) //
{
return false;
}
else {
return str.indexOf(searchStr) >= 0;
}
}
// 保存每个月的天数
private static final int[] DAYS_OF_MONTH = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
// 日历的起始年份
public static final int START_YEAR = 1900;
// 日历的结束年份
public static final int END_YEAR = 2100;
private static final String ZERO_STRING = "0";
/***************************************************************************
* 匹配英文字母 或者汉字 如"Shenzhen" "深圳"
*
* @param str
* 待匹配字符串
* @return true 匹配通过 false 匹配失败
*/
public static boolean isValidEnglishOrChinese(String str) {
// 1、[A-Za-z]* 英文字母的匹配 一次或者多次
// 2、[\u4E00-\u9FA5]* 汉字匹配 一次或者多次
boolean flag = false;
Pattern p = Pattern.compile("^[A-Za-z]*|[\u4E00-\u9FA5]*$");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
}
return flag;
}
/***************************************************************************
* 匹配英中文姓名 与英文名 英文名格式为：姓与名之间用/隔开 例如Green/Jim King
*
* @param str
* 待匹配字符串
* @return true 匹配通过 false 匹配失败
*/
public static boolean isValidName(String str) {
// 1、[A-Za-z]* 英文字母的匹配 一次或者多次
// 2、[\u4E00-\u9FA5]* 汉字匹配 一次或者多次
boolean flag = false;
Pattern p = Pattern.compile("^([A-Za-z]+[\\/][A-Za-z]+)|[\u4E00-\u9FA5]*");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
}
return flag;
}
/***************************************************************************
* 验证身份证号码 15位 18位
*
* @param cardStr
* 身份证字符串
* @return true 合法 false 不合法
*/
public static boolean isValidIdCard(String cardStr) {
boolean flag = false;
Pattern pEighteen = Pattern.compile("^\\d{17}(\\d{1}|x)$");// 18位身份证号码
// 包括末尾是“x”的校验码
Pattern pFifteen = Pattern.compile("^\\d{15}$");// 15位身份证号码
if (cardStr != null) {
if (pEighteen.matcher(cardStr).matches()) // 18位身份证号码验证通过
{
if (isValidDate(cardStr.substring(6, 14)))// 18位身份证号码
// 出生年月日验证通过
{
flag = true;
}
}
if (pFifteen.matcher(cardStr).matches()) // 15位身份证号码验证通过
{
if (isValidDay(cardStr.substring(6, 12))) // 15位身份证出身年月日的验证
{
flag = true;
}
}
}
return flag;
}
/***************************************************************************
* 正整数验证
*
* @param str
* 待验证字符串
* @return true 验证通过 false 验证失败
*/
public static boolean isValidInteger(String str) {
boolean flag = false;
Pattern p = Pattern.compile("^\\d*$");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
}
return flag;
}
/***************************************************************************
* 整数验证(包括正整数与 负整数)
*
* @param str
* 待验证字符串
* @return true 验证通过 false 验证失败
*/
public static boolean isValidNo(String str) {
boolean flag = false;
Pattern p = Pattern.compile("^-?\\d*$");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
}
return flag;
}
/**
* 验证非负整数(正整数+0)
*
* @param str
* 待验证字符串
* @return true 验证通过 false 验证失败
*/
public static boolean isValidNonNegative(String str) {
boolean flag = false;
Pattern p = Pattern.compile("^\\d+$");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
}
return flag;
}
/**
* 验证非负整数(正整数+0)
*
* @param str
* 待验证字符串
* @return true 验证通过 false 验证失败
*/
public static boolean isValidPositiveInteger(String str) {
boolean flag = false;
Pattern p = Pattern.compile("^\\d+$");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
if (ZERO_STRING.equals(str)) {
flag = false;
}
}
return flag;
}
/***************************************************************************
* 匹配英文字母(汉语拼音)
*
* @param str
* 待匹配字符串
* @return true 匹配通过 false 匹配失败
*/
public static boolean isValidEnglish(String str) {
boolean flag = false;
Pattern p = Pattern.compile("^[A-Za-z]*$");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
}
return flag;
}
/***************************************************************************
* 匹配英文字母 或者汉字，数字 过滤特殊字符
*
* @param str
* 待匹配字符串
* @return true 匹配通过 false 匹配失败
*/
public static boolean isValidNonSpecialChar(String str) {
boolean flag = false;
Pattern p = Pattern.compile("^[A-Za-z\u4E00-\u9FA5\\d]*$");
if (str != null) {
Matcher match = p.matcher(str);
flag = match.matches();
}
return flag;
}
/**
* 验证HH时间格式的时间范围是否大于等于三小时 **注意此方法必须在isValidHour格式验证通过后调用
*
* @param startHour
* 开始时间 HH
* @param endHour
* 结束时间HH
* @return true 通过 false 不通过
*/
public static boolean isVaildHourZone(String startHour, String endHour) {
boolean flag = false;
if (startHour != null && endHour != null) {
if (isValidHour(startHour) && isValidHour(endHour)) // 格式验证，避免可能抛类型转换异常
{
int sHour = Integer.parseInt(startHour);
int eHour = Integer.parseInt(endHour);
flag = (eHour - sHour >= 3);
}
}
return flag;
}
/***************************************************************************
* 验证结束时间是否大于开始时间 **注意：此方法必须先调用isValidDate 方法后调用 yyMMdd
*
* @param startDate
* 开始时间
* @param endDate
* 结束时间
* @return true 验证通过 false 验证失败
*/
public static boolean isValidTimeZone(String startDate, String endDate) {
boolean flag = false;
if (startDate != null && endDate != null) {
if (isValidDate(startDate) && isValidDate(endDate)) // 格式验证，避免可能抛类型转换异常
{
flag = (Integer.parseInt(endDate) > Integer.parseInt(startDate));
}
}
return flag;
}
/***************************************************************************
* 验证结束时间是否大于等于开始时间 **注意：此方法必须先调用isValidDate 方法后调用 yyMMdd（包含等于）
*
* @param startDate
* 开始时间
* @param endDate
* 结束时间
* @return true 验证通过 false 验证失败
*/
public static boolean isValidTwoTimes(String startDate, String endDate) {
boolean flag = false;
if (startDate != null && endDate != null) {
if (isValidDate(startDate) && isValidDate(endDate)) // 格式验证，避免可能抛类型转换异常
{
flag = (Integer.parseInt(endDate) > Integer.parseInt(startDate) || Integer.parseInt(endDate) == Integer
.parseInt(startDate));
}
}
return flag;
}
/***************************************************************************
* 验证电话号码 后可接分机号 区号3位或者4位 电话7位或者8位后 后面可加3位或者4位分机号
*
* @param telephoeNo
* 电话号码字符串
* @return
*/
public static boolean isValidTelephoeNo(String telephoeNo) {
// 1、\\d{3,4} 区号 3位或者4位的匹配
// 2、\\d{7,8} 号码 7味或者8位的匹配
// 3、(\\d{3,4})? 分机号3位或者4位的匹配 ？可匹配一次或者两次
boolean flag = false;
Pattern p = Pattern.compile("^\\d{3,4}\\d{7,8}(\\d{3,4})?$");
Matcher match = p.matcher(telephoeNo);
if (telephoeNo != null) {
flag = match.matches();
}
return flag;
}
/***************************************************************************
* 验证手机号码
*
* @param telNo
* 电话号码字符串 130到139 和 150，152 ，157，158，159 ，186，189，187
* @return
*/
public static boolean isValidMobileNo(String mobileNo) {
// 1、(13[0-9])|(15[02789])|(18[679]) 13段 或者15段 18段的匹配
// 2、\\d{8} 整数出现8次
boolean flag = false;
// Pattern p = Pattern.compile("^(1[358][13567890])(\\d{8})$");
Pattern p = Pattern.compile("^((13[0-9])|(15[02789])|(18[679]))\\d{8}$");
Matcher match = p.matcher(mobileNo);
if (mobileNo != null) {
flag = match.matches();
}
return flag;
}
/***************************************************************************
* 验证是否是正确的邮箱格式
*
* @param email
* @return true表示是正确的邮箱格式,false表示不是正确邮箱格式
*/
public static boolean isValidEmail(String email) {
// 1、\\w+表示@之前至少要输入一个匹配字母或数字或下划线 \\w 单词字符：[a-zA-Z_0-9]
// 2、(\\w+\\.)表示域名. 如新浪邮箱域名是sina.com.cn
// {1,3}表示可以出现一次或两次或者三次.
String reg = "\\w+@(\\w+\\.){1,3}\\w+";
Pattern pattern = Pattern.compile(reg);
boolean flag = false;
if (email != null) {
Matcher matcher = pattern.matcher(email);
flag = matcher.matches();
}
return flag;
}
/***************************************************************************
* 验证整点时间格式是否正确 HH格式 时间范围00时~23时
*
* @param hour
* 时间格式字符串
* @return true表示是正确的整点时间格式,false表示不是正确整点时间格式
*/
public static boolean isValidHour(String hour) {
boolean flag = false;
String reg = "^[0-2][0-9]$";
Pattern pattern = Pattern.compile(reg);
if (hour != null) {
Matcher matcher = pattern.matcher(hour);
flag = matcher.matches();
int firstNum = Integer.parseInt(hour.substring(0, 1));
if (flag && firstNum == 2) {
int secondNum = Integer.parseInt(hour.substring(1, 2));
flag = secondNum < 4; // 时间小于24时
}
}
return flag;
}
/***************************************************************************
* 匹配日期格式 yyMMdd 并验证日期是否合法 此方法忽略了闰年的验证 用于15位身份证出生日期的验证
*
* @param dayStr
* 日期字符串
* @return true 日期合法 false 日期非法
*/
public static boolean isValidDay(String dayStr) {
Pattern p = Pattern.compile("^\\d{2}\\d{2}\\d{2}$");
Matcher match = p.matcher(dayStr);
if (dayStr != null) {
if (match.matches()) // 格式验证通过 yyMMdd
{
int month = Integer.parseInt(dayStr.substring(2, 4)); // 月
int day = Integer.parseInt(dayStr.substring(4, 6)); // 日
if (!isValidMonth(month)) {
return false; // 月份不合法
}
if (!(day >= 1 && day <= DAYS_OF_MONTH[month - 1])) {
return false; // 日期不合法
}
return true;
}
return false;
}
else {
return false;
}
}
/***************************************************************************
* 匹配日期格式 yyyyMMdd 并验证日期是否合法
*
* @param date
* 日期字符串
* @return true 日期合法 false 日期非法
*/
public static boolean isValidDate(String date) {
// 1、 \\d{4} 年，\\d{2}月，\\d{2}日匹配
Pattern p = Pattern.compile("^\\d{4}\\d{2}\\d{2}$");
Matcher match = p.matcher(date);
if (date != null) {
if (match.matches()) // 格式验证通过 yyyyMMdd
{
int year = Integer.parseInt(date.substring(0, 4)); // 年
int month = Integer.parseInt(date.substring(4, 6)); // 月
int day = Integer.parseInt(date.substring(6, 8)); // 日
if (!isValidYear((year))) {
return false; // 年份不在有效年份中
}
if (!isValidMonth(month)) {
return false; // 月份不合法
}
if (!isValidDay(year, month, day)) {
return false; // 日期不合法
}
return true;
}
return false;
}
else {
return false;
}
// return Pattern.matches("", date);
}
/**
* 检查year是否在有效的年份范围内 此处验证大于1900年 小于2101年
*
* @param year
* @return
*/
public static boolean isValidYear(int year) {
return year >= START_YEAR && year <= END_YEAR;
}
/**
* 验证月份是否在有效月份内
*
* @param month
* @return
*/
public static boolean isValidMonth(int month) {
return month >= 1 && month <= 12;
}
/**
* 检查天数是否在有效的范围内，因为天数会根据年份和月份的不同而不同 所以必须依赖年份和月份进行检查
*
* @param year
* @param month
* @param day
* @return
*/
public static boolean isValidDay(int year, int month, int day) {
if (month == 2 && isLeapYear(year))// 闰年且是2月份
{
return day >= 1 && day <= 29;
}
return day >= 1 && day <= DAYS_OF_MONTH[month - 1];// 其他月份
}
/**
* 验证是否是闰年
*
* @param year
* @return
*/
public static boolean isLeapYear(int year) {
return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}
/**
* 验证用户名注册是否合法-----------由数字、26个英文字母或者下划线组成的字符串
*
* @param userName
* @return
*/
public static boolean isRegUserName(String userName) {
String str = "^\\w+$";
boolean flag = true;
if (userName != null) {
Pattern p = Pattern.compile(str);
Matcher match = p.matcher(userName);
flag = match.matches();
}
return flag;
}
/**
* 验证IP地址
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean isIP(String str) {
String num = "(25[0-5]|2[0-4]\\d|[0-1]\\d{2}|[1-9]?\\d)";
String regex = "^" + num + "\\." + num + "\\." + num + "\\." + num + "$";
return match(regex, str);
}
/**
* 验证网址Url
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean IsUrl(String str) {
String regex = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w- ./?%&=]*)?";
return match(regex, str);
}
/**
* 验证输入密码条件(字符与数据同时出现)
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean IsPassword(String str) {
String regex = "[A-Za-z]+[0-9]";
return match(regex, str);
}
/**
* 验证输入密码长度 (6-18位)
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean IsPasswLength(String str) {
String regex = "^\\d{6,18}$";
return match(regex, str);
}
/**
* 验证输入两位小数
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean IsDecimal(String str) {
String regex = "^[0-9]+(.[0-9]{2})?$";
return match(regex, str);
}
/**
* 验证输入经纬度
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean IsJingWeiDu(String str) {
String regex = "(-|\\+)?(180\\.0{2,6}|(\\d{1,2}|1([0-7]\\d))\\.\\d{2,6})";
return match(regex, str);
}
/**
* 验证大写字母
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean IsUpChar(String str) {
String regex = "^[A-Z]+$";
return match(regex, str);
}
/**
* 验证小写字母
*
* @param 待验证的字符串
* @return 如果是符合格式的字符串,返回 <b>true </b>,否则为 <b>false </b>
*/
public static boolean IsLowChar(String str) {
String regex = "^[a-z]+$";
return match(regex, str);
}
/**
* @param regex
* 正则表达式字符串
* @param str
* 要匹配的字符串
* @return 如果str 符合 regex的正则表达式格式,返回true, 否则返回 false;
*/
public static boolean match(String regex, String str) {
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
return matcher.matches();
}
/**
* 首字母转大写
* @param s
* @return
*/
public static String toUpperCaseFirstOne(String s){
return (new StringBuilder()).append(Character.toUpperCase(s.charAt(0))).append(s.substring(1)).toString();
}
/**
* 首字母转小写
* @param s
* @return
*/
public static String toLowerCaseFirstOne(String s){
return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
}
/**
* 将格式如class_name的字符串 转换成 ClassName格式
* @param s
* @return
*/
public static String toUpperCaseClassName(String s){
s = toUpperCaseFirstOne(s);
for (int i = 0; i < s.length(); i++) {
if(s.indexOf("_") !=-1){
s = (new StringBuilder()).append(s.substring(0,s.indexOf("_"))).append(Character.toUpperCase(s.charAt(s.indexOf("_")+1))).append(s.substring(s.indexOf("_") +2)).toString();
}else{
continue;
}
}
return s;
}
/**
* 将格式如class_name的字符串 转换成 className驼峰格式
* @param s
* @return
*/
public static String toUpperCasePropertyName(String s){
s = toLowerCaseFirstOne(s);
for (int i = 0; i < s.length(); i++) {
if(s.indexOf("_") !=-1){
s = (new StringBuilder()).append(s.substring(0,s.indexOf("_"))).append(Character.toUpperCase(s.charAt(s.indexOf("_")+1))).append(s.substring(s.indexOf("_") +2)).toString();
}else{
continue;
}
}
return s;
}
public static BigDecimal formatString(String str) {
Pattern pattern = Pattern.compile("^\\d+\\.\\d+|\\d+$");
boolean matcher = pattern.matcher(str).find();
if (matcher) {
BigDecimal f;
if (str.contains("%")) {
f = new BigDecimal(str.replace("%", "")) .multiply(new BigDecimal(0.01)) ;
return f;
} else {
f = new BigDecimal(str);
return f;
}
} else {
return new BigDecimal(0);
}
}
public static String ChineseCharactersHandler(String str) {
str = str.replaceAll("[^(\u4e00-\u9fa5)]", "");
return str;
}
public static String NumberHandler(String str) {
str = str.replaceAll("[^(0-9)]", "");
return str;
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
