该类里包含了Java中常用的字符串处理方法,如日期处理、金额转换...
-----------------------------------------------------------------------------------------
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Enumeration;
import java.util.StringTokenizer;
import java.util.Vector;
/**
*
* 转换工具类
*
*/
public class ChangeUtil {
/**
* 时间格式(年月日)
*/
public static final String DATE_FORMAT_YMD = "yyyyMMdd";
/**
* 时间格式(年月)
*/
public static final String DATE_FORMAT_YM = "yyyyMM";
/**
* 时间格式(年)
*/
public static final String DATE_FORMAT_Y = "yyyy";
public static final String DATE_FORMAT_YMD_HMS="yyyy-MM-dd HH:mm:ss";
/**
* ChangeUtil类的缺省构造器。
*/
private ChangeUtil() {
}
/**
* 将一个以‘,‘分割的字符串,转换为一个Vector对象。这是changeStringToVector(String str, String token)的简化版本。
*
* @param _str 需要转换的字符串
* @return 包含了字符串中元素的Vector对象。
* @see #changeStringToVector
*/
public static Vector changeStringToVector(String _str){
return changeStringToVector(_str, ",");
}
/**
* 将一个以字符串token分割的字符串,转换为一个Vector对象。如"姓名[token]年龄"被转换为一个Vector,该Vector包含两个元素,第一个是"姓名",第二个是"年龄"。
*
* @param _str 需要转换的字符串
* @param _token 字符串中分割的token。如空格" ",或":"等。
* @return 包含了字符串中元素的Vector对象。
*/
public static Vector changeStringToVector(String _str, String _token) {
if( _str== null) {
return null;
}
Vector<String> temp = new Vector<String>();
StringTokenizer st = new StringTokenizer(_str, _token);
while (st.hasMoreTokens()) {
temp.add(st.nextToken());
}
return temp;
}
/**
* 将一个Vector对象中保存的字符串元素使用","分隔符转换为一个字符串,这是public static Vector changeStringToVector(String str)的逆操作。
*
* @param _v 包含了字符串数据元素的Vector对象
* @return 一个以","为分隔符的字符串
*/
public static String changeVectorToString(Vector _v) {
return changeVectorToString(_v, ",");
}
/**
* 将一个Vector对象中保存的字符串元素使用token分隔符转换为一个字符串,
* 这是public static Vector changeStringToVector(String str, String token)的逆操作。
* @param _v 包含了字符串数据元素的Vector对象
* @param _token 字符串中分割的token。如空格" ",或":"等。
* @return 一个以token为分隔符的字符串
*/
public static String changeVectorToString(Vector _v, String _token) {
if( _v == null) {
return null;
}
Enumeration enumeration = _v.elements();
String str = "";
while (enumeration.hasMoreElements()) {
str = str + (String) (enumeration.nextElement()) + _token;
}
str = str.substring(0, str.length() - 1);
return str;
}
/**
* 将一个字符串数组中保存的字符串元素使用","分隔符转换为一个字符串。
*
* @param _strArray 包含了字符串数据元素的字符串数组
* @return 一个以","为分隔符的字符串
* @see #changeArrayToString
*/
public static String changeArrayToString(String[] _strArray) {
return changeArrayToString(_strArray, ",");
}
/**
* 将一个字符串数组中保存的字符串元素使用token分隔符转换为一个字符串,
* 这是public static Vector changeStringToVector(String str, String token)的逆操作。
* @param _strArray 包含了字符串数据元素的字符串数组
* @param _token 分隔字符串使用的分隔符。
* @return 一个以token为分隔符的字符串
*/
public static String changeArrayToString(String[] _strArray,String _token) {
if( _strArray == null) {
return null;
}
int size = _strArray.length;
if (size == 0) {
return null;
} else if (size == 1) {
return _strArray[0];
} else {
String temp = _strArray[0];
for (int i = 1; i < size; i++) {
temp = temp + _token + _strArray[i];
}
return temp;
}
}
/**
* 将一个使用","分隔符分隔的字符串,转变为一个字符串数组。
*
* @param _str 用token分隔符分隔的字符串
* @return 字符串数组
*/
public static String[] changeStringToArray(String _str) {
return changeStringToArray(_str, ",");
}
/**
* 将一个使用token分隔符分隔的字符串,转变为一个字符串数组。
*
* @param _str 用token分隔符分隔的字符串
* @param _token 字符串的分隔符
* @return 字符串数组
*/
public static String[] changeStringToArray(String _str, String _token) {
if( _str ==null) {
return null;
}
Vector v = changeStringToVector(_str, _token);
String[] strArray = new String[v.size()];
int i = 0;
for (Enumeration em = v.elements(); em.hasMoreElements(); i++) {
strArray[i] = (String) em.nextElement();
}
return strArray;
}
/**
* 获得以参数_fromDate为基数的年龄
*
* @param _birthday 生日
* @param _fromDate 起算时间
* @return 年龄(起算年-出生年)
*/
public static int getAgeFromBirthday(java.util.Date _birthday,java.util.Date _fromDate) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_birthday);
int birthdayYear = calendar.get(Calendar.YEAR);
int birthdayMonth = calendar.get(Calendar.MONTH);
int birthdayDay = calendar.get(Calendar.DAY_OF_MONTH);
calendar.clear();
calendar.setTime(_fromDate);
int currentYear = calendar.get(Calendar.YEAR);
int currentMonth = calendar.get(Calendar.MONTH);
int currentDay = calendar.get(Calendar.DAY_OF_MONTH);
calendar.clear();
int age = currentYear - birthdayYear;
if (!((currentMonth >= birthdayMonth)&& (currentDay >= birthdayDay))) {
age--;
}
return age;
}
/**
* 获得当前年龄
*
* @param _birthday 生日
* @return 年龄(起算年-出生年)
*/
public static int getAgeFromBirthday(java.util.Date _birthday) {
return getAgeFromBirthday(_birthday,new java.util.Date(System.currentTimeMillis()));
}
/**
* 获得当前年龄
*
* @param _birthday 生日
* @return 年龄(起算年-出生年)
*/
public static int getAgeFromBirthday(java.sql.Timestamp _birthday) {
return getAgeFromBirthday(new java.util.Date(_birthday.getTime()),new java.util.Date(System.currentTimeMillis()));
}
/**
* 使用格式{@link #DATE_FORMAT_YMD}格式化日期输出
*
* @param _date 日期对象
* @return 格式化后的日期
*/
public static String formatDate(java.util.Date _date) {
return formatDate(_date, DATE_FORMAT_YMD);
}
/**
* 使用格式<b>_pattern</b>格式化日期输出
*
* @param _date 日期对象
* @param _pattern 日期格式
* @return 格式化后的日期
*/
public static String formatDate(java.util.Date _date, String _pattern) {
if( _date == null) {
return null;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(_pattern);
String stringDate = simpleDateFormat.format(_date);
return stringDate;
}
/**
* 使用中文字符以简单的形式("年 月 日")格式化时间串
*
* @param _date 日期对象
* @return 格式化后的日期
*/
public static String simplefFormatChineseDate(java.util.Date _date) {
if( _date == null) {
return null;
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
StringBuffer sb = new StringBuffer();
sb.append(calendar.get(Calendar.YEAR))
.append("年")
.append(calendar.get(Calendar.MONTH) + 1)
.append("月")
.append(Calendar.DAY_OF_MONTH)
.append("日");
calendar.clear();
return sb.toString();
}
/**
* 使用中文字符以复杂的形式("年 月 日 上午 时 分 秒")格式化时间串
*
* @param _date 日期对象
* @return 格式化后的日期
*/
public static String complexFormatChineseDate(java.util.Date _date) {
if( _date == null) {
return null;
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
StringBuffer sb = new StringBuffer();
sb.append(calendar.get(Calendar.YEAR))
.append("年")
.append(calendar.get(Calendar.MONTH) + 1)
.append("月")
.append(Calendar.DAY_OF_MONTH)
.append("日")
.append(Calendar.HOUR_OF_DAY)
.append("时")
.append(Calendar.MINUTE)
.append("分")
.append(Calendar.SECOND)
.append("秒");
calendar.clear();
return sb.toString();
}
/**
* 将时间串转变为时间对象,输入参数<b>_dateStr</b>必须遵循格式{@link #DATE_FORMAT_YMD}
*
* @param _dateStr 时间串
* @return 时间对象
*/
public static java.util.Date changeToDate(String _dateStr) throws IllegalArgumentException{
return changeToDate(_dateStr, DATE_FORMAT_YMD);
}
/**
* 将时间串转变为时间对象
*
* @param _dateStr 时间串
* @param _pattern 时间串使用的模式
* @return 时间对象
* @throws ParamValidateException 当输入的时间串和它使用的模式不匹配时掷出
*/
public static java.util.Date changeToDate(String _dateStr,String _pattern) throws IllegalArgumentException {
if (_dateStr == null || _dateStr.trim().equals("")) {
return null;
}
java.util.Date date = null;
SimpleDateFormat format = new SimpleDateFormat(_pattern);
try {
date = format.parse(_dateStr);
} catch (java.text.ParseException pe) {
throw new IllegalArgumentException("不能使用模式:[" + _pattern + "]格式化时间串:[" + _dateStr + "]");
}
return date;
}
/**
* 将时间串转变为数据库时间对象,输入参数<b>_dateStr</b>必须遵循格式{@link #DATE_FORMAT_YMD}
*
* @param _dateStr 时间串
* @return 数据库时间对象
*/
public static java.sql.Date changeToDBDate(String _dateStr) throws IllegalArgumentException{
return changeForDBDate(changeToDate(_dateStr, DATE_FORMAT_YMD));
}
/**
* 将时间串转变为数据库时间对象
*
* @param _dateStr 时间串
* @param _pattern 时间串使用的模式
* @return 时间对象
* @throws ParamValidateException 当输入的时间串和它使用的模式不匹配时掷出
*/
public static java.sql.Date changeToDBDate(String _dateStr,String _pattern) throws IllegalArgumentException {
return changeForDBDate(changeToDate(_dateStr, _pattern));
}
/**
* 将java.util.Date对象转换为java.sql.Date对象
*
* @param _date 待转化的java.util.Date 对象
* @return java.sql.Date对象
*/
public static java.sql.Date changeForDBDate(java.util.Date _date) {
if (_date == null) {
return null;
}
return new java.sql.Date(_date.getTime());
}
/**
* 将java.sql.Date对象转换为java.util.Date对象
*
* @param _date 待转化的java.sql.Date对象
* @return java.util.Date对象
*/
public static java.util.Date changFromDBDate(java.sql.Date _date) {
return (java.util.Date) _date;
}
/**
* 将java.util.Date对象转换为java.sql.Timestamp对象
*
* @param _date 待转化的java.util.Date 对象
* @return java.sql.Timestamp对象
*/
public static java.sql.Timestamp changeToTimestamp(java.util.Date _date) {
if (_date == null) {
return null;
}
return new java.sql.Timestamp(_date.getTime());
}
/**
* 将java.sql.Timestamp对象转换为java.util.Date对象
*
* @param _date 待转化的java.sql.Timestamp 对象
* @return java.util.Date 对象
*/
public static java.util.Date changeFromTimestamp(java.sql.Timestamp _date) {
return (java.util.Date) _date;
}
/**
* 改变字符串的编码方式(ISO8859_1)为(GBK),以支持中文
*
* @param _str 待转变的字符串
* @return 采用GBK编码的字符串
*/
public static String changeToGB(String _str) throws Exception{
if( _str == null) {
return null;
}
String gbStr = null;
try {
gbStr = new String(_str.getBytes("ISO8859_1"), "GBK");
} catch (Exception e) {
throw e;
}
return gbStr;
}
/**
* 改变字符串的编码方式(GBK)为(ISO8859_1)
*
* @param _str 待转变的字符串
* @return 采用ISO8859_1编码的字符串
*/
public static String changeFromGB(String _str)throws Exception {
if( _str == null) {
return null;
}
String isoStr = null;
try {
isoStr = new String(_str.getBytes("GBK"), "ISO8859_1");
} catch (Exception e) {
throw e;
}
return isoStr;
}
/**
* 获得日期的年
*
* @param _date 日期对象
* @return 日期的年
*/
public static int getYear(java.util.Date _date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
int year = calendar.get(Calendar.YEAR);
calendar.clear();
return year;
}
/**
* 获得日期的月
*
* @param _date 日期对象
* @return 日期的月
*/
public static int getMonth(java.util.Date _date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
// 以0开始
int month = calendar.get(Calendar.MONTH);
calendar.clear();
return (month + 1);
}
/**
* 获得日期的天,以月为基
*
* @param _date 日期对象
* @return 日期的天
*/
public static int getDay(java.util.Date _date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
int day = calendar.get(Calendar.DAY_OF_MONTH);
calendar.clear();
return day;
}
/**
* 获得日期的小时
*
* @param _date 日期对象
* @return 日期的小时
*/
public static int getHours(java.util.Date _date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
int value = calendar.get(Calendar.HOUR);
calendar.clear();
return value;
}
/**
* 获得日期的分钟
*
* @param _date 日期对象
* @return 日期的分钟
*/
public static int getMinutes(java.util.Date _date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
int value = calendar.get(Calendar.MINUTE);
calendar.clear();
return value;
}
/**
* 获得日期的小秒
*
* @param _date 日期对象
* @return 日期的秒
*/
public static int getSeconds(java.util.Date _date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_date);
int value = calendar.get(Calendar.SECOND);
calendar.clear();
return value;
}
/**
* 计算两个日期间相隔的天数
*
* @param _startDate 起始日期
* @param _endDate 终止日期
* @return 相隔天数, 如果结果为正表示<b>_endDate</b>在<b>_startDate</b>之后;如果结果为负表示<b>_endDate</b>在<b>_startDate</b>之前;
* 如果结果为0表示<b>_endDate</b>和<b>_startDate</b>是同一天。
*/
public static int getDayCount(java.util.Date _startDate,java.util.Date _endDate) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(_startDate);
int startDay = calendar.get(Calendar.DAY_OF_YEAR);
int startYear = calendar.get(Calendar.YEAR);
calendar.clear();
calendar.setTime(_endDate);
int endDay = calendar.get(Calendar.DAY_OF_YEAR);
int endYear = calendar.get(Calendar.YEAR);
calendar.clear();
return (endYear - startYear) * 365 + (endDay - startDay);
}
/**
* 获得两个Date间的月数, 天数超过14天算1个月
*
* @param _startDate 开始时间
* @param _endDate 结束时间
* @return 两个Date间的月数
*/
public static int getMonthAmount(java.sql.Date _startDate,java.sql.Date _endDate) {
int nYear = 0;
int nMonth = 0;
int nDay = 0;
int nMonthAmount = 0;
Calendar cldStart = Calendar.getInstance();
Calendar cldEnd = Calendar.getInstance();
cldStart.setTime(_startDate);
cldEnd.setTime(_endDate);
nYear = cldEnd.get(Calendar.YEAR) - cldStart.get(Calendar.YEAR);
nMonth = cldEnd.get(Calendar.MONTH) - cldStart.get(Calendar.MONTH);
nDay = cldEnd.get(Calendar.DATE) - cldStart.get(Calendar.DATE);
if (nDay > 14) {
nMonthAmount = nYear * 12 + nMonth + 1;
} else {
nMonthAmount = nYear * 12 + nMonth;
}
return nMonthAmount;
}
/**
* 格式化长整形数
*
* @param _inStrObj 长整形字串对象
* @return 长整形数
*/
public static long toLong(Object _inStrObj) {
if (_inStrObj == null || _inStrObj.toString().trim().equals("")) {
return 0;
} else {
return Long.valueOf(_inStrObj.toString()).longValue();
}
}
/**
* 格式化整形数
*
* @param _inStrObj 整形数字串对象
* @return 整形数
*/
public static int toInteger(Object _inStrObj) {
if (_inStrObj == null || _inStrObj.toString().trim().equals("")) {
return 0;
} else {
return new Integer(_inStrObj.toString()).intValue();
}
}
/**
* 格式化双精浮点数
*
* @param _inStrObj 双精浮点数字串对象
* @return 双精度浮点数,
*/
public static double toDouble(Object _inStrObj) {
if (_inStrObj == null || _inStrObj.toString().trim().equals("")) {
return 0;
} else {
return Double.valueOf(_inStrObj.toString()).doubleValue();
}
}
/**
* 格式化浮点数
*
* @param _inStrObj 浮点数字串对象
* @return 浮点数,如果数据格式错误,或字串为空,这返回0
*/
public static float toFloat(Object _inStrObj) {
if (_inStrObj == null || _inStrObj.toString().trim().equals("")) {
return 0;
} else {
return Float.valueOf(_inStrObj.toString()).floatValue();
}
}
/**
* 将字节数组采用编码<b>_encoding</b>转化为字符串
*
* @param _bytes 字节数组
* @param _encoding 编码方式
* @throws ParamValidateException 如果编码方式不支持时掷出
* @return 字符串
*/
public static String toStr(byte[] _bytes, String _encoding) throws IllegalArgumentException{
if( _bytes == null) {
return null;
}
String s = null;
try {
s = new String(_bytes, _encoding);
} catch (Exception e) {
throw new IllegalArgumentException("不支持的编码方式:" + _encoding);
}
return s;
}
/**
* 格式化布尔对象
*
* @param _boolean 布尔对象
* @return 布尔对象的值,如果<b>_boolean</b>为null, 返回false
*/
public static boolean toBoolean(Boolean _boolean) {
if (_boolean == null) {
return false;
} else {
return _boolean.booleanValue();
}
}
/**
* 获得对象的字符串表示, 当<b>_obj</b>为null时用<b>_replaceStr</b>替代
*
* @param _obj 对象
* @param _replaceStr 替代null值的字符串
* @return 处理后的字符串
*/
public static String toStr(Object _obj, String _replaceStr) {
if (_obj == null) {
return _replaceStr;
} else {
return _obj.toString();
}
}
/**
* 字符串处理, 当<b>_str</b>为null时用<b>_replaceStr</b>替代
*
* @param _str 原始字符串
* @param _replaceStr 替代null值的字符串
* @return 处理后的字符串
*/
public static String toStr(String _str, String _replaceStr) {
if (_str == null||_str.equals("null")) {
return _replaceStr;
} else {
return _str;
}
}
/**
* 字符串处理, 当<b>_str</b>为null时用<b>""</b>替代
*
* @param _str 原始字符串
* @return 处理后的字符串
*/
public static String toStr(String _str) {
return toStr(_str, "");
}
/**
* 获得对象的字符串表示, 当<b>_obj</b>为null时用<b>""</b>替代
*
* @param _obj 对象
* @return 获得对象的字符串
*/
public static String toStr(Object _obj) {
if(_obj==null) {
return "";
}else{
return toStr(_obj.toString());
}
}
/**
* 将字符串采用编码<b>_encoding</b>转化为字节数组
*
* @param _str 字符串
* @param _encoding 编码方式
* @throws ParamValidateException 如果编码方式不支持时掷出
* @return 字节数组
*/
public static byte[] toBytes(String _str, String _encoding) throws IllegalArgumentException{
if( _str == null) {
return null;
}
byte[] b = null;
try {
b = _str.getBytes(_encoding);
} catch (Exception e) {
throw new IllegalArgumentException("不支持的编码方式:" + _encoding);
}
return b;
}
/**
* 将双精浮点数代表的金额转化中文大写形式
*
* @param _dMoney 代表双精浮点数的金额
* @return 金额的中文大写形式,如果输入参数<b>dMoney</b>大于10^8或小于0.01返回空串。
*/
public static String toChinese(double _dMoney) {
String[] strArr = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
String[] strArr1 = { "分", "角", "圆", "拾", "佰", "仟", "万", "拾", "佰", "仟" };
String[] strArr2 = new String[10];
String sRtn = "";
int iTmp;
double dTmp;
try {
_dMoney += 0.001;
if ((_dMoney >= 100000000) || (_dMoney < 0.01)) {
sRtn = "";
} else {
for (int i = 0; i < 10; i++) {
dTmp = _dMoney / Math.pow(10, 7 - i);
iTmp = (new Double(dTmp)).intValue();
_dMoney -= iTmp * Math.pow(10, 7 - i);
if (iTmp != 0) {
strArr2[i] = strArr[iTmp] + strArr1[9 - i];
} else {
strArr2[i] = "";
}
}
boolean bFlag = false;
for (int i = 0; i < 10; i++) {
if (!"".equals(strArr2[i])) {
sRtn += strArr2[i];
bFlag = true;
} else {
if (i == 3) {
sRtn += "万";
bFlag = true;
} else if (i == 7) {
sRtn += "圆";
bFlag = true;
} else if (bFlag) {
sRtn += "零";
bFlag = false;
}
}
}
if (sRtn.startsWith("万")) {
sRtn = sRtn.substring(1, sRtn.length());
}
if (sRtn.startsWith("圆")) {
sRtn = sRtn.substring(1, sRtn.length());
}
while (sRtn.startsWith("零")) {
sRtn = sRtn.substring(1, sRtn.length());
}
if (sRtn.lastIndexOf("零") == (sRtn.length() - 1)) {
sRtn = sRtn.substring(0, sRtn.length() - 1);
}
if (sRtn.startsWith("圆")) {
sRtn = sRtn.substring(1, sRtn.length());
}
iTmp = sRtn.indexOf("圆");
if (iTmp != -1) {
if ("零".equals(sRtn.substring(iTmp - 1, iTmp))) {
sRtn =
sRtn.substring(0, iTmp - 1)
+ sRtn.substring(iTmp, sRtn.length());
}
}
iTmp = sRtn.indexOf("万");
if (iTmp != -1) {
if ("零".equals(sRtn.substring(iTmp - 1, iTmp))) {
sRtn =
sRtn.substring(0, iTmp - 1)
+ sRtn.substring(iTmp, sRtn.length());
}
}
while (sRtn.startsWith("零")) {
sRtn = sRtn.substring(1, sRtn.length());
}
sRtn += "整";
}
} catch (Exception ex) {
}
return sRtn;
}
/**
* 根据输入的String返回BigDecimal,或者若String非数字串,返回null
*
* @param _str 待转化的字符串
* @return BigDecimal对象
*/
public static BigDecimal toBigDecimal(String _str) {
BigDecimal bd = null;
if (_str != null) {
try {
bd = new BigDecimal(_str);
} catch (Exception e) {
return null;
}
}
return bd;
}
/**
* 根据年,月,日,转化为Timestamp类型,便于DB插入处理
*
* @param _sDate 格式为:yyyy-mm-dd
* @return Timestamp的时间格式
*/
public static Timestamp toTimestamp(String _sDate) {
Timestamp ts = null;
if (_sDate == null || "".equals(_sDate)) {
return null;
}
ts = Timestamp.valueOf(_sDate + " 00:00:00.000000000");
return ts;
}
/**
* 替换Html文档中的" "为" ", "<"为"<", ">"为">","<br>"为"\r\n"
*
* @param _rawStr 原始Html文档
* @return 替换后的Html文档
*/
public static String changeHtmlStr(String _rawStr) {
String str = null;
if (_rawStr != null) {
str = replaceString( " ", " ", _rawStr);
str = replaceString( "<","<", str);
str = replaceString( ">",">", str);
str = replaceString( "&","&", str);
str = replaceString( ""","\"", str);
str = replaceString( "<br>", "\r\n",str);
}
return str;
}
/**
* 使用新串替换原有字符串中老串
*
* @param _oldStr 待替换的字符串
* @param _newStr 新字符串
* @param _wholeStr 整个字符串
* @return 替换后新串
*/
public static String replaceString(String _oldStr,String _newStr,String _wholeStr) {
if( _wholeStr == null){
return null;
}
if( _newStr == null) {
return _wholeStr;
}
int start=0, end=0;
StringBuffer result=new StringBuffer();
result=result.append(_wholeStr);
while ( result.indexOf(_oldStr, start)>-1) {
start=result.indexOf(_oldStr, start);
end=start+_oldStr.length();
result.replace(start,end,_newStr);
start += _newStr.length();
}
return result.toString();
}
/**
* 如果是正向替换,使用新串替换原有字符串中第一个老串;如果是逆向替换,使用新串替换原有字符串中最后一个老串
*
* @param _oldStr 待替换的字符串
* @param _newStr 新字符串
* @param _wholeStr 整个字符串
* @param _reverse 替换方向,如果为false正向替换,否则逆向替换
* @return 替换后新串
*/
public static String replaceFirstString(String _oldStr,String _newStr,String _wholeStr, boolean _reverse) {
if( _wholeStr == null){
return null;
}
if( _newStr == null) {
return _wholeStr;
}
StringBuffer result=new StringBuffer(_wholeStr);
int start=0, end=0;
if(!_reverse) {
if (result.indexOf(_oldStr)>-1) {
start=result.indexOf(_oldStr);
end=start+_oldStr.length();
result.replace(start,end,_newStr);
}
}else{
if (result.lastIndexOf(_oldStr)>-1) {
start=result.lastIndexOf(_oldStr);
end=start+_oldStr.length();
result.replace(start,end,_newStr);
}
}
return result.toString();
}
/**
* 将字符串转换为HTML形式,以便在JavaScript中使用
*
* @param _sourceStr 原字符串
* @return 转换后的字符串
*/
public static String changeToHTMLStr(String _sourceStr) {
if (_sourceStr == null) {
return null;
}
StringBuffer buff = new StringBuffer(1024);
int n = _sourceStr.length();
char c;
for (int i = 0; i < n; i++) {
c = _sourceStr.charAt(i);
if (c == ‘"‘) {
buff.append(‘\\‘);
buff.append(c);
} else if (c == ‘\\‘) {
buff.append(‘\\‘);
buff.append(c);
} else if (c == ‘\r‘) {
buff.append("\\r");
} else if (c == ‘\n‘) {
buff.append("\\n");
} else {
buff.append(c);
}
}
return buff.toString();
}
/**
* 得到 _value截取小数点后_len位 以后的值
*
* @param _value 原值
* @param _len 小数点后的位数
* @return 截取以后的值
*/
public static float roundFloat(float _value, int _len) throws IllegalArgumentException{
int iLen = _len;
checkParamPositive("_len", _len);
float d = (float) Math.pow(10, iLen);
float fValue = _value * d;
return Math.round(fValue) / d;
}
/**
* 获得float的字符串表示,首先对_value按_len进行四舍五入截位,如果截位后小数点后位数小于_len,则使用0补齐。
*
* @param _value 原值
* @param _len 小数点后的位数
* @return float的字符串
*/
public static String formatFloat(float _value, int _len) throws IllegalArgumentException{
String fStr = String.valueOf(roundFloat(_value, _len));
StringBuffer sb = new StringBuffer(fStr);
int leftBit = fStr.length() - fStr.indexOf(".") - 1;
if (leftBit < _len) {
for (int i = 0; i < (_len - leftBit); i++) {
sb.append("0");
}
}
return sb.toString();
}
/**
* 得到 _value截取小数点后_len位 以后的值
*
* @param _value 原值
* @param _len 小数点后的位数
* @return 截取以后的值
*/
public static double roundDouble(double _value, int _len) throws IllegalArgumentException {
int iLen = _len;
checkParamPositive("_len", _len);
double d = Math.pow(10, iLen);
double dValue = _value * d;
return Math.round(dValue) / d;
}
/**
* 获得double的字符串表示,首先对_value按_len进行四舍五入截位,如果截位后小数点后位数小于_len,则使用0补齐。
*
* @param _value 原值
* @param _len 小数点后的位数
* @return double的字符串
*/
public static String formatDouble(double _value, int _len) throws IllegalArgumentException{
String fStr = String.valueOf(roundDouble(_value, _len));
StringBuffer sb = new StringBuffer(fStr);
int leftBit = fStr.length() - fStr.indexOf(".") - 1;
if (leftBit < _len) {
for (int i = 0; i < (_len - leftBit); i++) {
sb.append("0");
}
}
return sb.toString();
}
/**
* 获得字符串的左边<p>_len</p>个字符串
*
* @param _str 字符串
* @param _len 长度
* @return <p>_len</p>个字符串
*/
public static String leftString(String _str, int _len) {
if (_str == null) {
return null;
}
if (_len < 0) {
return "";
}
if (_str.length() <= _len) {
return _str;
} else {
return _str.substring(0, _len);
}
}
/**
* 获得字符串的右边<p>_len</p>个字符串
*
* @param _str 字符串
* @param _len 长度
* @return 字符串的右边<p>_len</p>个字符串
*/
public static String rightString(String _str, int _len) {
if (_str == null) {
return null;
}
if (_len < 0) {
return "";
}
if (_str.length() <= _len) {
return _str;
} else {
return _str.substring(_str.length() - _len);
}
}
/**
* 右填充字符<p>_padChar</p>,使整个字符串长度为<p>_size</p>
*
* @param _str 原始字符串
* @param _size 添充后字符的总长度
* @param _padChar 待填充字符
* @return 右填充后的字符串,如:rightPad(‘hell‘, 3, ‘0‘)=hell;rightPad(‘hell‘, 10, ‘0‘)=hell000000
*/
public static String rightPad(String _str, int _size, char _padChar) {
if (_str == null) {
return null;
}
int pads = _size - _str.length();
if (pads <= 0) {
return _str; // returns original String when possible
}
return _str.concat(padding(pads, _padChar));
}
/**
* 左填充字符<p>_padChar</p>,使得填充后的字符串总长为<p>_size</p>
*
* @param _str 原始字符串
* @param _size 添充后字符的总长度
* @param _padChar 待填充字符
* @return 左填充后的字符串,如:leftPad(‘hell‘, 10, ‘0‘)=000000hell;leftPad(‘hell‘, 3, ‘0‘)=hell
*/
public static String leftPad(String _str, int _size, char _padChar) {
if (_str == null) {
return null;
}
int pads = _size - _str.length();
if (pads <= 0) {
return _str; // returns original String when possible
}
return padding(pads, _padChar).concat(_str);
}
/**
* 字符串<p>padChar</p>重复<p>repeat</p>位
*
* @param _repeat 重复次数
* @param _padChar 待重复字符
* @return 重复后的结果字串,如:padding(5, ‘a‘)=aaaaa;padding(0, ‘a‘):""
*/
private static String padding(int _repeat, char _padChar) {
String value = "";
String padStr = String.valueOf(_padChar);
if(_repeat>0) {
for(int i = 0;i<_repeat;i++) {
value = value.concat(padStr);
}
}
return value;
}
private static void checkParamPositive(String _str, int _value) throws IllegalArgumentException {
if (_value <= 0) {
throw new IllegalArgumentException("参数:" + _str + "不能小于等于0");
}
}
}