stringutils.java

java版源代码,里面包含很多源代码,大家可以看看.

  private static final char[] zeroArray = "0000000000000000".toCharArray();

  /**
   * 生成前面补0的字符
   * Pads the supplied String with 0's to the specified length and returns
   * the result as a new String. For example, if the initial String is
   * "9999" and the desired length is 8, the result would be "00009999".
   * This type of padding is useful for creating numerical values that need
   * to be stored and sorted as character data. Note: the current
   * implementation of this method allows for a maximum <tt>length</tt> of
   * 16.
   *
   * @param string the original String to pad.
   * @param length the desired length of the new padded String.
   * @return a new String padded with the required number of 0's.
   */
  public static final String zeroPadString(String string, int length) {
    if (string == null || string.length() > length) {
      return string;
    }
    StringBuffer buf = new StringBuffer(length);
    buf.append(zeroArray, 0, length - string.length()).append(string);
    return buf.toString();
  }

  // 替换字符串函数
  // String strSource - 源字符串
  // String strFrom   - 要替换的子串
  // String strTo     - 替换为的字符串
  public static String replace(String strSource, String strFrom, String strTo) {
    // 如果要替换的子串为空，则直接返回源串
    if (strFrom == null || strFrom.equals(""))
      return strSource;
    String strDest = "";
    // 要替换的子串长度
    int intFromLen = strFrom.length();
    int intPos;
    // 循环替换字符串
    while ( (intPos = strSource.indexOf(strFrom)) != -1) {
      // 获取匹配字符串的左边子串
      strDest = strDest + strSource.substring(0, intPos);
      // 加上替换后的子串
      strDest = strDest + strTo;
      // 修改源串为匹配子串后的子串
      strSource = strSource.substring(intPos + intFromLen);
    }
    // 加上没有匹配的子串
    strDest = strDest + strSource;
    // 返回
    return strDest;
  }

  /**
   * 获得字符串
   * @param value Integer
   * @return String
   */
  public static String stringValue(Integer value) {
    if (value == null)
      return null;
    return String.valueOf(value);
  }

  /**
   * 获得字符串
   * @param value Integer
   * @return String
   */
  public static String stringValue(Double value) {
    if (value == null)
      return null;
    return String.valueOf(value);
  }

  /**
   * 获得字符串
   * @param value Integer
   * @return String
   */
  public static String stringValue(Long value) {
    if (value == null)
      return null;
    return String.valueOf(value);
  }

  /**
   * 获得字符串
   * @param value Integer
   * @return String
   */
  public static String stringValue(Short value) {
    if (value == null)
      return null;
    return String.valueOf(value);
  }

  /**
   * 分割字符串
   * @param Str String 原始字符串
   * @param splitchar char 分割字符
   * @return ArrayList
   */
  public static ArrayList Split(String Str, char splitchar) {
    if (Str != null) {
      ArrayList ret = new ArrayList();
      StringBuffer tmpBuffer = new StringBuffer();
      for (int i = 0; i < Str.length(); i++) {
        if (Str.charAt(i) != splitchar)
          tmpBuffer.append(Str.charAt(i));
        else {
          ret.add(tmpBuffer.toString());
          tmpBuffer.delete(0, tmpBuffer.length());
        }
      }
      if (tmpBuffer.length() > 0) {
        ret.add(tmpBuffer.toString());
        tmpBuffer.delete(0, tmpBuffer.length());
      }

      return ret;

    }
    else
      return new ArrayList();
  }

  /**
   * BCD编码
   * @param str String 输入字符串,一般用于时间表示
   * @return byte[]
   */
  public static byte[] str2bcd(String str) {
    String s = str.toUpperCase();
    int ii = str.length();
    byte[] b = new byte[ii / 2];
    for (int i = 0, j = 0; i < ii; i++, j++) {
      int i1, i2;
      if (s.charAt(i) - 'A' >= 0)
        i1 = s.charAt(i) - 'A' + 10;
      else
        i1 = s.charAt(i) - '0';

      if (s.charAt(i + 1) - 'A' >= 0)
        i2 = s.charAt(i + 1) - 'A' + 10;
      else
        i2 = s.charAt(i + 1) - '0';

      b[j] = (byte) (i1 * 0x10 + i2);
      i = i + 1;
    }
    return b;
  }

  /**
   * BBCode替换字符串
   * @param Str String
   * @param BStr String
   * @param EStr String
   * @param ReStr String
   * @return String
   * 例如
   * BStr = "[b]";
       EStr = "[/b]";
       ReStr = "<b>$lichao$</b>";
       Str = LCReplace(Str, BStr, EStr, ReStr);
   */
  public static String LCReplace(String Str, String BStr, String EStr,
                                 String ReStr) {
    String ReturnStr = "", Str1 = "", Str2 = "";
    int i, j, n;
    n = 0;
    if ( (Str.indexOf(BStr) > -1) && ( (Str.indexOf(EStr) > -1))) {
      while (Str.indexOf(BStr, n) > -1) {
        i = Str.indexOf(BStr);
        j = Str.indexOf(EStr);
        Str1 = Str.substring( (i + BStr.length()), j);

        Str2 = StringUtils.replace(ReStr, "$lichao$", Str1);

        Str1 = BStr + Str1 + EStr;
        Str = StringUtils.replace(Str, Str1, Str2);
        n = i + Str2.length() - Str1.length();
      }
    }
    ReturnStr = Str;
    return ReturnStr;
  }

  /**
   * 将字符串的数字取出到一个字符串中
   * @param s String
   * @return String
   */
  public static String getDigitsOnly(String s) {
    StringBuffer digitsOnly = new StringBuffer();
    char c;
    for (int i = 0; i < s.length(); i++) {
      c = s.charAt(i);
      if (Character.isDigit(c)) {
        digitsOnly.append(c);
      }
    }
    return digitsOnly.toString();
  }

  /**
   * 校验信用卡号是否正确
   * http://www.merriampark.com/anatomycc.htm
   * @param cardNumber String
   * @return boolean
   */
  public static boolean isValidCreditCard(String cardNumber) {
    String digitsOnly = getDigitsOnly(cardNumber);
    int sum = 0;
    int digit = 0;
    int addend = 0;
    boolean timesTwo = false;

    for (int i = digitsOnly.length() - 1; i >= 0; i--) {
      digit = Integer.parseInt(digitsOnly.substring(i, i + 1));
      if (timesTwo) {
        addend = digit * 2;
        if (addend > 9) {
          addend -= 9;
        }
      }
      else {
        addend = digit;
      }
      sum += addend;
      timesTwo = !timesTwo;
    }

    int modulus = sum % 10;
    return modulus == 0;

  }

  /**
   * 查找在StartStr和EndStr中间的字符串
   * @param in String 输入
   * @param StartStr String 开始字符串
   * @param EndStr String 结束字符串
   * @return ArrayList 返回结果
   */
  public static ArrayList findString(String in, String StartStr, String EndStr) {
    ArrayList Arr = new ArrayList();

    while (true) {
      int from = in.indexOf(StartStr, 0);
      if (from == -1)
        break;
      in = in.substring(from + StartStr.length(), in.length());

      int to = in.indexOf(EndStr, 0);
      int mid = in.indexOf(StartStr);
      if ( (mid > to || mid == -1) && to != -1)
        Arr.add(in.substring(0, to));

    }
    return Arr;

  }

  /**
   * 返回字符串的Unicode代码
   * @param text String
   * @return String
   */
  public static String toUnicode(String text) {
    StringBuffer strBuffer = new StringBuffer();
    if (text == null) {
      return "";
    }
    char[] cArray = text.toCharArray();
    final int cArrayLength = cArray.length;
    strBuffer.delete(0, strBuffer.length());
    String hexStr;
    for (int i = 0; i < cArrayLength; i++) {
      strBuffer.append("\\u");
      hexStr = Integer.toHexString(cArray[i]);
      for (int j = 0; j < 4 - hexStr.length(); j++) {
        strBuffer.append('0');
      }
      strBuffer.append(hexStr);
    }
    return strBuffer.toString();
  }

  /**
   * 判断给定IP地址是否在规定的网段内
   * @param IPAddress String IP地址,例如:192.168.1.120
   * @param NetworkAddress String 子网地址 例如:192.168.1.0
   * @param MaskAddress String 子网掩码 例如:255.255.255.0
   * @return boolean
   */
  public static boolean isvalid(String IPAddress, String NetworkAddress,
                                String MaskAddress) {
    boolean flag = true;
    String[] ips = IPAddress.split("\\.");
    String[] mas = MaskAddress.split("\\.");
    String[] nws = NetworkAddress.split("\\.");

    try {
      if (ips.length < 4 || mas.length < 4 || nws.length < 4) {
        return false;
      }
      for (int i = 3; i >= 0; i--) {
        int nw = Integer.parseInt(ips[i]) & Integer.parseInt(mas[i]);
        if (Integer.parseInt(nws[i]) != nw) {
          return false;
        }
      }
      return flag;
    }
    catch (Exception ex) {
      return false;
    }
  }
}