常用的Java字元轉換工具類

来源:http://www.cnblogs.com/skycsdn/archive/2016/03/21/javaStringUtil.html
-Advertisement-
Play Games

該類里包含了Java中常用的字元串處理方法,如日期處理、金額轉換... import java.math.BigDecimal;import java.sql.Timestamp;import java.text.SimpleDateFormat;import java.util.Calendar;


該類里包含了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文檔中的"&nbsp"為" ", "&lt"為"<", "&gt"為">","<br>"為"\r\n"
  *
  * @param _rawStr 原始Html文檔
  * @return 替換後的Html文檔
  */
public static String changeHtmlStr(String _rawStr) {
  String str = null;
  if (_rawStr != null) {
   str = replaceString( "&nbsp;", " ", _rawStr);
   str = replaceString( "&lt;","<", str);
   str = replaceString( "&gt;",">", str);
   str = replaceString( "&amp;","&", str);
   str = replaceString( "&quot;","\"", 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 重覆次數
  *

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 1.先來瞭解一下TCP連接建立與關閉過程中的各種狀態: CLOSED:初始狀態,表示沒有任何連接。LISTEN:Server端的某個Socket正在監聽來自遠方的TCP埠的連接請求。SYN_SENT:發送連接請求後等待確認信息。當客戶端Socket進行Connect連接時,會首先發送SYN包,隨即
  • 本篇翻譯的是Elasticsearch官方文檔中的一些技巧,是使用Elasticsearch必不可少的必備知識,並且適用於所有的Rest Api。 返回數據格式化 當在Rest請求後面添加 時,結果會以Json格式化的方式顯示。另外,如果添加 結果會以樹的形式顯示,預設都是Flase. 返回數據的易
  • 重載(overloading) (1)方法重載是讓類以統一的方式處理不同類型數據的一種手段。多個同名函數同時存在,具有不同的參數個數/類型。重載Overloading是一個類中多態性的一種表現。 (2) Java的方法重載,就是在類中可以創建多個方法,它們具有相同的名字,但具有不同的參數和不同的定義
  • XML DTD 文檔類型定義(DTD)可定義合法的XML文檔構建模塊。它使用一系列合法的元素來定義文檔結構。 DTD可被聲明於XML文檔中,也可以作為一個外部的引用。 內部的DOCTYPE聲明 假如DTD被包含在您的XML源文件中,它應當通過下麵的語法被包含在一個DOCTYPE中。 <!DOCTYP
  • //通用單選按鈕驗證 使用例子: extAttr="validateAttr=type=radio;" function f_check_radio(obj){ //獲取相同的name的Radio組 var radioNames = $names(obj.name); var len = radio
  • 原文地址:http://www.jb51.net/article/38102.htm ps:好久沒更新python代碼了,這次用到了字元串,轉來看看 Python 截取字元串使用 變數[頭下標:尾下標],就可以截取相應的字元串,其中下標是從0開始算起,可以是正數或負數,下標可以為空表示取到頭或尾。
一周排行
    -Advertisement-
    Play Games
  • 移動開發(一):使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說,近來想嘗試開發一款安卓APP,考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP,畢竟是使用Visual Studio開發工具,使用起來也比較的順手,結合微軟官方的教程進行了安卓 ...
  • 前言 QuestPDF 是一個開源 .NET 庫,用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫,它徹底改變了我們生成 PDF 文檔的方 ...
  • 項目地址 項目後端地址: https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址: ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址: http://tree ...
  • 話不多說,直接開乾 一.下載 1.官方鏈接下載: https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe,運行開始下載SQL server; 二. ...
  • 前言 隨著物聯網(IoT)技術的迅猛發展,MQTT(消息隊列遙測傳輸)協議憑藉其輕量級和高效性,已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫,為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog支持多種接收器用於日誌存儲,增強器用於添加屬性,LogContext管理動態屬性,支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項,適用於不同需求。 ...
  • 目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據,爬取信息時需要模擬瀏覽器行為,否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下: 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • 1.前言 什麼是熱更新 游戲或者軟體更新時,無需重新下載客戶端進行安裝,而是在應用程式啟動的情況下,在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR,Xlua,ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles,Addressable, ...
  • 本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺,其實像阿裡雲,騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後,它會送 ...
  • 通過以下方式可以高效,並保證數據同步的可靠性 1.API設計 使用RESTful設計,確保API端點明確,並使用適當的HTTP方法(如POST用於創建,PUT用於更新)。 設計清晰的請求和響應模型,以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證,確保接收到的數據符合預期格 ...