学步园

package com.luang.util.common;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.text.DecimalFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.luang.util.date.DateUtil;

public class StrUtil
{
  public static final String STRING_SPILTOR = ";";
  public static final String JSON_STRING_SPILTOR = ",";

  public static String getLastToken(String str, String tokenSeparator)
  {
    return str.substring(str.lastIndexOf(tokenSeparator) + 1, str.length());
  }

  public static boolean isNull(String s)
  {
    return (s == null) || (s.length() < 1);
  }

  public static boolean isNull(String s, String val)
  {
    return (isNull(s)) || (s.compareTo(val) == 0);
  }

  public static String stackTrace(Throwable t)
  {
    StringWriter sw = new StringWriter();
    t.printStackTrace(new PrintWriter(sw));
    String s = sw.toString();
    try {
      sw.close();
    } catch (IOException localIOException) {
    }
    return s;
  }

  public static String dbString(String v) {
    StringBuffer sb = new StringBuffer();
    return "'" + v + "'";
  }

  public static String dumpHashTable(Hashtable table, boolean html) {
    Enumeration keys = table.keys();
    Enumeration values = table.elements();
    StringBuffer sb = new StringBuffer();
    String eof = "\n";
    if (html)
      eof = "<br>\n";
    while (keys.hasMoreElements()) {
      sb.append("  key [").append(keys.nextElement().toString()).append("] = [").append(
        values.nextElement().toString()).append("]").append(eof);
    }
    return sb.toString();
  }

  public static String addURLParameter(String URL, String paramName, String paramValue)
  {
    String param = paramName + "=" + paramValue;
    return addURLParameter(URL, param);
  }

  public static String addURLParameter(String URL, String parameter)
  {
    StringBuffer sb = new StringBuffer(URL);
    if (URL.lastIndexOf('?') == -1)
      sb.append("?");
    else
      sb.append("&");
    sb.append(parameter);
    return sb.toString();
  }

  public static String remove(String str, String until)
  {
    String val = null;
    int indx = str.indexOf(until);
    if (indx != -1)
      val = str.substring(indx + until.length(), str.length());
    return val;
  }

  public static Long String2Long(String str)
  {
    Long l = new Long(0L);
    try {
      l = Long.valueOf(str);
    } catch (NumberFormatException ex) {
      ex.printStackTrace();
    }
    return l;
  }

  public static int String2PageId(String str)
  {
    int i;
    try
    {
      i = Integer.parseInt(str);
    }
    catch (NumberFormatException ex)
    {
      i = 1;
    }
    return i;
  }

  public static String NullToString(String str)
  {
    if (str == null)
      str = "";
    return str;
  }

  public static String NullToZero(String str)
  {
    if (str == null)
      str = "0";
    return str;
  }

  public static BigDecimal NullToBigDecimal(BigDecimal decimal)
  {
    if (decimal == null)
      decimal = BigDecimal.valueOf(0L);
    return decimal;
  }

  public static String htmlToSql(String strHtml)
  {
    StringBuffer strSql = null;
    if (strHtml != null) {
      strSql = new StringBuffer();
      for (int i = 0; i < strHtml.length(); i++) {
        String temp = strHtml.substring(i, i + 1);
        if (temp.equals("'"))
          strSql.append("''");
        else {
          strSql.append(temp);
        }
      }
      return strSql.toString();
    }
    return "";
  }

  public static String sqlToHtml(String strSql)
  {
    StringBuffer strHtml = null;
    if (strSql != null) {
      strHtml = new StringBuffer();
      for (int i = 0; i < strSql.length(); i++) {
        String temp = strSql.substring(i, i + 1);
        if (temp.equals("'"))
          strHtml.append("'");
        else if (temp.equals(">"))
          strHtml.append("&gt;");
        else if (temp.equals("<"))
          strHtml.append("&lt;");
        else if (temp.equals("&"))
          strHtml.append("&amp;");
        else if (temp.equals("\""))
          strHtml.append("&quot;");
        else {
          strHtml.append(temp);
        }
      }
      return strHtml.toString();
    }
    return "";
  }

  public static String formatDouble(double dblDigit, int scale)
  {
    String temp = "##,###,###,###,###.";
    for (int i = 0; i < scale; i++) {
      temp = temp + "#";
    }
    return new DecimalFormat(temp).format(dblDigit);
  }

  public static String urlEncode(String strURL)
  {
    try
    {
      strURL = URLEncoder.encode(strURL, "gb2312");
    } catch (UnsupportedEncodingException localUnsupportedEncodingException) {
    }
    return strURL;
  }

  public static String urlDecode(String strURL)
  {
    try
    {
      strURL = URLDecoder.decode(strURL, "gb2312");
    } catch (UnsupportedEncodingException localUnsupportedEncodingException) {
    }
    return strURL;
  }

  public static HashMap getFilesOfJPG(String filePath)
    throws Exception
  {
    HashMap hmFile = new HashMap();
    int index = 0;
    File file = new File(filePath);
    String[] files = file.list();
    if (files != null) {
      for (int i = 0; i < files.length; i++) {
        String fileName = files[i];
        index = fileName.indexOf(".");
        if (index >= 0) {
          String key = fileName.substring(0, index);
          key = key.toLowerCase();
          String extend = fileName.substring(index + 1, 
            fileName.length());
          extend = extend.toLowerCase();
          hmFile.put(key, fileName);
        }
      }
    }

    return hmFile;
  }

  public static int getDigitCountForString(String str)
    throws Exception
  {
    String temp = "";
    int count = 0;
    for (int i = 0; i < str.length(); i++) {
      temp = str.substring(i, i + 1);
      if ((temp.compareTo("0") >= 0) && (temp.compareTo("9") <= 0)) {
        count++;
      }
    }
    return count;
  }

  public static int getTerm(Date rxDate, Date curDate) throws Exception {
    int termNo = 0;
    String strRXDate = DateUtil.formatDate(rxDate, 0);
    String strCurDate = DateUtil.formatDate(curDate, 0);
    if (strRXDate.equals(""))
      return termNo;
    if (strCurDate.equals(""))
      return termNo;
    int rxYear = Integer.parseInt(strRXDate.substring(0, 4));
    int rxMonth = Integer.parseInt(strRXDate.substring(5, 7));
    int curYear = Integer.parseInt(strCurDate.substring(0, 4));
    int curMonth = Integer.parseInt(strCurDate.substring(5, 7));
    if (rxYear < curYear) {
      int count = 0;
      int month = curMonth - rxMonth;
      if (rxMonth > 7) {
        if (month < 0)
          count = 0;
        else
          count = 1;
      } else if (month > 5)
        count = 2;
      else
        count = 1;
      termNo = (curYear - rxYear) * 2 + count;
    } else if (rxYear == curYear) {
      int month = curMonth - rxMonth;
      if (month > 5)
        termNo = 2;
      else
        termNo = 1;
    }
    return termNo;
  }

  public static String[] splitString(String str, String splitor, int count)
    throws Exception
  {
    String[] strResult = new String[count];
    int i = 0;
    int index = 0;
    for (index = str.indexOf(splitor); index >= 0; ) {
      String temp = str.substring(0, index);
      strResult[i] = temp;
      str = str.substring(index + 1, str.length());
      index = str.indexOf(splitor);
      i++;
    }

    strResult[i] = str;
    return strResult;
  }

  public static Vector splitString(String str, String splitor)
    throws Exception
  {
    Vector vResult = new Vector();
    int i = 0;
    int index = 0;
    for (index = str.indexOf(splitor); index >= 0; ) {
      String temp = str.substring(0, index);
      vResult.add(temp);
      str = str.substring(index + 1, str.length());
      index = str.indexOf(splitor);
      i++;
    }

    vResult.add(str);
    return vResult;
  }

  public static double getRate(double numerator, double denominator, int decimalLength)
  {
    int[] length = { 100, 1000, 10000, 100000, 1000000, 10000000 };
    double rate = 0.0D;
    rate = numerator / denominator;
    rate *= length[decimalLength];
    rate = Math.round(rate);
    rate = rate * 100.0D / length[decimalLength];
    return rate;
  }

  public static String digitToUpper(String strDigit)
  {
    String result = "";
    String[] digits = { "锛?", "涓?", "浜?", "涓?", "鍥?", 
      "浜?", "鍏?", "涓?", "鍏?", "涔?" };
    int length = strDigit.length();
    String strChar = "";
    int digit = 0;
    String max = "9";
    String min = "0";
    for (int i = 0; i < length; i++) {
      strChar = strDigit.substring(i, i + 1);
      if ((strChar.compareTo(min) >= 0) && (strChar.compareTo(max) <= 0)) {
        digit = Integer.parseInt(strChar);
        strChar = digits[digit];
      }
      result = result + strChar;
    }

    return result;
  }

  public static String intToUpper(String strInt)
  {
    String result = "";
    String[] digits = { "锛?", "涓?", "浜?", "涓?", "鍥?", 
      "浜?", "鍏?", "涓?", "鍏?", "涔?" };
    String[] units = { "", "鍗?", "鐧?", "鍗?", "涓?", 
      "鍗?", "鐧?", "鍗?", "浜?", "鍗?", "鐧?", 
      "鍗?", "涓?", "鍗?", "鐧?", "鍗?" };
    int length = 0;
    int bit = 0;
    String strChar = "";
    String strCharUpper = "";
    int digit = 0;
    String max = "9";
    String min = "0";
    int nInt = 0;
    String flag = "0";
    try {
      nInt = Integer.parseInt(strInt);
      strInt = String.valueOf(nInt);
    } catch (Exception e) {
      return strInt;
    }
    length = strInt.length();
    bit = length;
    for (int i = 0; i < length; i++) {
      strChar = strInt.substring(i, i + 1);
      if ((strChar.compareTo(min) >= 0) && (strChar.compareTo(max) <= 0)) {
        digit = Integer.parseInt(strChar);
        strCharUpper = digits[digit];
      }
      if ((nInt >= 10) && (nInt < 20) && (i == 0))
        flag = "1";
      else if ((nInt <= 9) || (nInt >= 100) || (strChar.compareTo(min) != 0))
        result = result + strCharUpper;
      bit--;
      result = result + units[bit];
    }

    return result;
  }

  public static String getErrorMsg(Exception e)
  {
    System.out.println("         ###################          ");
    System.out.println(" @error: " + e.toString());
    System.out.println("         ###################          ");
    String error = e.getMessage();
    if (error == null)
      error = "";
    if (error.indexOf("error.") < 0)
      error = "error.system";
    return error;
  }

  public static float getRoundFloat(float f, int type)
    throws Exception
  {
    BigDecimal b = new BigDecimal(f);
    float f1 = b.setScale(type, 4).floatValue();
    return f1;
  }

  public static String getLimitLengthString(String str, int len, String symbol)
    throws UnsupportedEncodingException
  {
    if ((str == null) || (str.equals("")))
      return str;
    if (len == 0)
      return str;
    int counterOfDoubleByte = 0;
    byte[] b = str.getBytes("GBK");
    if (b.length <= len)
      return str;
    for (int i = 0; i < len; i++) {
      if (b[i] < 0)
        counterOfDoubleByte++;
    }
    if (counterOfDoubleByte % 2 == 0) {
      return new String(b, 0, len, "GBK") + symbol;
    }
    return new String(b, 0, len - 1, "GBK") + symbol;
  }

  public static String getPropertyValueOfObject(Object obj)
  {
    String result = "";
    Class cObj = obj.getClass();
    Field[] fields = cObj.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
      Field fieldObj = fields[i];
      if ((fieldObj.getName().equals("logUtil")) || 
        (fieldObj.getName().equals("ds")) || 
        (fieldObj.getName().equals("alArea")) || 
        (fieldObj.getName().equals("serialVersionUID")) || 
        (fieldObj.getName().equals("alOrder")) || 
        (fieldObj.getName().equals("sql"))) continue;
      String temp = fieldObj.getName();
      String firstWord = temp.substring(0, 1);
      temp = firstWord.toUpperCase() + 
        temp.substring(1, temp.length());
      String methodName = "get" + temp;
      try {
        Method methodObj = cObj.getMethod(methodName, null);
        String methodValue = "";
        Object valueObj = methodObj.invoke(obj, null);
        if (valueObj != null)
          methodValue = NullToString(valueObj.toString());
        result = result + fieldObj.getName() + ":" + methodValue + 
          ";";
      } catch (Exception e) {
        e.printStackTrace();
      }

    }

    return result;
  }

  public static String interception(double v1) {
    String apjs = String.valueOf(v1);
    int m = apjs.indexOf(".");
    if (apjs.length() > m + 2)
      apjs = apjs.substring(0, m + 3);
    return apjs;
  }

  public static String formatString(String strSrc, String[] objs)
  {
    StringBuffer sbTemp = new StringBuffer();
    int i = 0;
    String temp = "";
    int index = 0;
    for (index = strSrc.indexOf("%"); (index > -1) && (objs.length > i); i++) {
      sbTemp.append(strSrc.substring(0, index));
      temp = objs[i];
      sbTemp.append(temp);
      strSrc = strSrc.substring(index + 2, strSrc.length());
      index = strSrc.indexOf("%");
    }

    sbTemp.append(strSrc);
    return sbTemp.toString();
  }

  public static String matcherStr(String str, String cp, String replacement)
  {
    if ((str == null) || (str.equals(""))) {
      return "";
    }
    String txt = str;
    Pattern p = Pattern.compile(cp, 2);
    Matcher m = p.matcher(txt);
    txt = m.replaceAll(replacement);
    return txt;
  }

  public static String getClass1By(String class2)
  {
    if ((class2 == null) || (class2.equals("")))
      return "";
    String class1 = "";
    if (class2.length() > 4)
      class1 = class2.substring(0, 4);
    return class1;
  }

  public static String formatString(String srcStr, char fillChar, int len, int direct)
  {
    String retStr = srcStr;
    if (srcStr != null) {
      if (srcStr.length() > len) {
        retStr = retStr.substring(0, len);
      } else if (srcStr.length() < len) {
        StringBuffer sf = new StringBuffer();
        for (int i = 0; i < len - srcStr.length(); i++) {
          sf.append(fillChar);
        }
        if (direct == 0)
          retStr = sf.toString() + retStr;
        else
          retStr = retStr + sf.toString();
      }
    } else {
      StringBuffer sf = new StringBuffer();
      for (int i = 0; i < len; i++) {
        sf.append(fillChar);
      }
      retStr = sf.toString();
    }
    return retStr;
  }

  public static String formatDouble(double dblDigit)
  {
    String pattern = "###################.###";
    DecimalFormat format = new DecimalFormat(pattern);
    String result = format.format(dblDigit);
    return result;
  }

  public static String replace(String targetStr, String beReplace, String replace)
  {
    if (targetStr == null)
      return null;
    if ((beReplace == null) || (beReplace.equals("")))
      return targetStr;
    if (replace == null)
      replace = "";
    StringBuffer stringbuffer = new StringBuffer();
    int i = 0;
    int index = targetStr.indexOf(beReplace);
    int length = beReplace.length();
    for (; index > -1; index = targetStr.indexOf(beReplace, i)) {
      stringbuffer.append(targetStr.substring(i, index) + replace);
      i = index + length;
    }

    stringbuffer.append(targetStr.substring(i));
    return stringbuffer.toString();
  }

  public static String escapeChar(String str)
  {
    String retvalue = "";
    retvalue = replace(str, "&", "&amp;");
    return retvalue;
  }

  public static String reEscapeChar(String str)
  {
    String retvalue = "";
    retvalue = replace(str, "&amp;", "&");
    return retvalue;
  }

  public static String replaceFirst(String targetStr, String beReplace, String replace)
  {
    if (targetStr == null)
      return null;
    if ((beReplace == null) || (beReplace.equals("")))
      return targetStr;
    if (replace == null)
      replace = "";
    StringBuffer stringbuffer = new StringBuffer();
    int i = 0;
    int length = beReplace.length();
    int index = targetStr.indexOf(beReplace);
    if (index > -1) {
      stringbuffer.append(targetStr.substring(i, index) + replace);
      i = index + length;
      stringbuffer.append(targetStr.substring(i));
      return stringbuffer.toString();
    }
    return targetStr;
  }

  public static String replaceLast(String targetStr, String beReplace, String replace)
  {
    if (targetStr == null)
      return null;
    if ((beReplace == null) || (beReplace.equals("")))
      return targetStr;
    if (replace == null)
      replace = "";
    StringBuffer str = new StringBuffer(512);
    for (int i = targetStr.length(); i > 0; i--) {
      str.append(targetStr.charAt(i - 1));
    }
    String temp = replaceFirst(str.toString(), beReplace, replace);
    str = new StringBuffer(512);
    for (int i = temp.length(); i > 0; i--) {
      str.append(temp.charAt(i - 1));
    }
    return str.toString();
  }

  public static String utf8Togb2312(String str)
  {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < str.length(); i++) {
      char c = str.charAt(i);
      switch (c) {
      case '+':
        sb.append(' ');
        break;
      case '%':
        try {
          sb.append((char)Integer.parseInt(
            str.substring(i + 1, i + 3), 16));
        }
        catch (NumberFormatException e) {
          throw new IllegalArgumentException();
        }
        i += 2;
        break;
      default:
        sb.append(c);
      }
    }

    String result = sb.toString();
    String res = null;
    try {
      byte[] inputBytes = result.getBytes("8859_1");
      res = new String(inputBytes, "UTF-8");
    } catch (Exception localException) {
    }
    return res;
  }

  public static String charsetDeCode(String str)
  {
    if ("".equals(str)) {
      return "";
    }

    StringBuffer sb = new StringBuffer("");
    str = str.replace(" ", "");
    try {
      for (int i = 0; i < str.length() - 3; i += 4)
        sb.append((char)Integer.valueOf(str.substring(i, i + 4), 16).intValue());
    }
    catch (Exception e) {
      System.out.print(e.getStackTrace());
      e.getStackTrace();
    }

    return sb.toString();
  }

  public static String charsetEncode(String str)
  {
    if ("".equals(str)) {
      return "";
    }

    StringBuffer strBuff = new StringBuffer("");
    try {
      byte[] b = str.getBytes("UTF-16");
      for (int n = 0; n < b.length; n++) {
        str = Integer.toHexString(b[n] & 0xFF);
        if (str.length() == 1)
          strBuff.append("0").append(str);
        else {
          strBuff.append(str);
        }

      }

      str = strBuff.toString().toUpperCase().substring(4);

      char[] chs = str.toCharArray();
      strBuff.delete(0, strBuff.length());
      for (int i = 0; i < chs.length; i += 4)
        strBuff.append(chs[i])
          .append(chs[(i + 1)])
          .append(chs[(i + 2)])
          .append(chs[(i + 3)])
          .append(" ");
    }
    catch (Exception e) {
      System.out.print(e.getStackTrace());
      e.getStackTrace();
    }

    return strBuff.toString();
  }
}