Java之String常用的公共方法UtilForString

public class UtilForString
{
   /**
    * 用base64算法加密字符串
    * 
    * @param content 输入字符串
    * @return 返回加密后的字符串
    */
   public static String encodeBase64(String content)
   {
      return com.sun.org.apache.xerces.internal.impl.dv.util.Base64.encode(content.getBytes());
   }

   /**
    * 用base64算法解密字符串
    * 
    * @param content
    * @return
    */
   public static String decodeBase64(String content)
   {
      try
      {
         return new String(com.sun.org.apache.xerces.internal.impl.dv.util.Base64.decode(content),
               "GBK");
      }
      catch(java.io.UnsupportedEncodingException e)
      {
         e.printStackTrace();
         return null;
      }
   }

   /**
    * 去子字符串，下标溢出也不会出错
    * 
    * @param src
    * @param begin
    * @return
    */
   public static String substring(String src, int begin)
   {
      return substring(src, begin, src.length());
   }

   /**
    * 取子字符串，下标溢出也不会出错
    * 
    * @param src 输入字符串
    * @param begin 开始位置
    * @param end 结束位置
    * @return
    */
   public static String substring(String src, int begin, int end)
   {
      if(isBlank(src) || src.length() < begin || begin > end)
         return "";
      if(end > src.length())
         return src.substring(begin);
      else
         return src.substring(begin, end);
   }

   /**
    * 转换字符串编码.
    * 
    * @param s the s
    * @param oldCharset the old charset
    * @param charset the new charset
    * @return the string
    */
   public static String transStr(String s, String oldCharset, String charset)
   {
      try
      {
         return new String(s.getBytes(oldCharset), charset);
      }
      catch(java.io.UnsupportedEncodingException e)
      {
         return s;
      }
   }

   /**
    * 返回字符串中某个字符串出现的次数
    * 
    * @param source 源字符串
    * @param str 匹配的字符串
    * @return 出现的次数
    */
   public static int matchTimes(String source, String str)
   {
      int result = 0;

      if(isBlank(source))
         return result;

      else
      {
         int fromIndex = 0;

         int index = 0;
         
         while((index = source.indexOf(str, fromIndex)) >= 0)
         {
            result++;
            fromIndex = index + 1;
         }
         
         return result;
      }
   }

   /**
    * 在长字符串指定的长度间隔处增加子字符串.
    * 
    * @param value
    * @param length
    * @param str
    * @return
    */
   public static String getConvertStr(String value, int length, String str)
   {
      StringBuilder sb = new StringBuilder();
      
      if(value.length() <= length)
         return value;
     
      for(int i = 0, n = value.length(); i < n; i = i + length)
      {
         if(i + length >= n)
            sb.append(value.substring(i));
         else
            sb.append(value.substring(i, i + length)).append(str);
      }
      
      return sb.toString();
   }

   /**
    * 人民币转成大写
    * 
    * @param value
    * @return String
    */
   public static String hangeToBig(double value)
   {
      char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
      char[] vunit = { '万', '亿' }; // 段名表示
      char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
      long midVal = (long)(value * 100); // 转化成整形
      
      String valStr = String.valueOf(midVal); // 转化成字符串
      String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
      String rail = valStr.substring(valStr.length() - 2); // 取小数部分
      String prefix = ""; // 整数部分转化的结果
      String suffix = ""; // 小数部分转化的结果
      
      // 处理小数点后面的数
      if(rail.equals("00"))// 如果小数部分为0
      { 
         suffix = "整";
      }
      else
      {
         suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
      }
      // 处理小数点前面的数
      char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
      char zero = '0'; // 标志'0'表示出现过0
      byte zeroSerNum = 0; // 连续出现0的次数
      
      for(int i = 0; i < chDig.length; i++)// 循环处理每个数字
      { 
         int idx = (chDig.length - i - 1) % 4; // 取段内位置
         int vidx = (chDig.length - i - 1) / 4; // 取段位置
         
         if(chDig[i] == '0')// 如果当前字符是0
         { 
            zeroSerNum++; // 连续0次数递增
            if(zero == '0')// 标志
            { 
               zero = digit[0];
            }
            else if(idx == 0 && vidx > 0 && zeroSerNum < 4)
            {
               prefix += vunit[vidx - 1];
               zero = '0';
            }
            continue;
         }
         zeroSerNum = 0; // 连续0次数清零
         if(zero != '0')// 如果标志不为0,则加上,例如万,亿什么的
         { 
            prefix += zero;
            zero = '0';
         }
         prefix += digit[chDig[i] - '0']; // 转化该数字表示
         if(idx > 0)
            prefix += hunit[idx - 1];
         if(idx == 0 && vidx > 0)
         {
            prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
         }
      }
      if(prefix.length() > 0)
         prefix += '圆'; // 如果整数部分存在,则有圆的字样
      
      return prefix + suffix; // 返回正确表示
   }

   /**
    * 全角字符转半角字符
    * 
    * @param QJStr
    * @return String
    */
   public static final String QJToBJChange(String QJStr)
   {
      char[] chr = QJStr.toCharArray();
      String str = "";
      
      for(int i = 0; i < chr.length; i++)
      {
         chr[i] = (char)((int)chr[i] - 65248);
         str += chr[i];
      }
      
      return str;
   }

   /**
    * 字符串转整型，不抛出异常
    * 
    * @param s
    * @return
    */
   public static Integer parseInt(String s)
   {
      Integer i = -1;
      if(!UtilForString.isBlank(s))
      {
         try
         {
            i = Integer.valueOf(s);
         }
         catch(Exception e)
         {
            e.printStackTrace();
         }
      }
      return i;
   }

   /**
    * 从字符串得到整型数组
    * 
    * @param str 输入的字符串
    * @param regx 分割字符串的表达式
    * @return 整型数组，如果为空则返回长度为0的数组，不返回null
    */
   public static int[] parseIntArray(String str, String regx)
   {
      if(UtilForString.isBlank(str))
         return new int[0];

      String[] days = str.split(regx);
      int[] ret = new int[days.length];
      int i = 0;

      for(String intString : days)
      {
         try
         {
            ret[i] = Integer.parseInt(intString);
         }
         catch(Exception e)
         {
            ret[i] = 0;
         }
         i++;
      }
      return ret;
   }

   /**
    * 分割字符串
    * 
    * @param str String 原始字符串
    * @param splitsign String 分隔符
    * @return String[] 分割后的字符串数组
    */
   public static String[] split(String str, String splitsign)
   {
      int index;

      if(str == null || splitsign == null)
         return null;

      java.util.ArrayList<String> al = new java.util.ArrayList<String>();

      while((index = str.indexOf(splitsign)) != -1)
      {
         al.add(str.substring(0, index));
         str = str.substring(index + splitsign.length());
      }
      al.add(str);

      return (String[])al.toArray(new String[0]);
   }

   /**
    * 替换字符串
    * 
    * @param source String 母字符串
    * @param from String 原始字符串
    * @param to String 目标字符串
    * @return String 替换后的字符串
    */
   public static String replace(String source, String from, String to)
   {
      if(source == null || from == null || to == null)
         return null;

      StringBuffer bf = new StringBuffer("");
      int index = -1;

      while((index = source.indexOf(from)) != -1)
      {
         bf.append(source.substring(0, index) + to);
         source = source.substring(index + from.length());
         index = source.indexOf(from);
      }
      bf.append(source);

      return bf.toString();
   }

   /**
    * 替换字符串，能能够在HTML页面上直接显示(替换双引号和小于号)
    * 
    * @param str String 原始字符串
    * @return String 替换后的字符串
    */
   public static String encodeHtml(String str)
   {
      if(str == null) { return null; }
      return replace(replace(str, "<", "<"), "\"", """);
   }

   /**
    * 替换字符串，将被编码的转换成原始码（替换成双引号和小于号）
    * 
    * @param str String
    * @return String
    */
   public static String htmldecode(String str)
   {
      if(str == null) { return null; }
      return replace(""", "\"", replace("<", "<", str));
   }

   /**
    * 是否为空白,包括null和""，"  "
    * 
    * @param str
    * @return
    */
   public static boolean isBlank(String str)
   {
      return str == null || str.trim().length() == 0;
   }

   /**
    * 判断两个字符串的值是否相等
    * 
    * @param s1 字符串1
    * @param s2 字符串2
    * @return 相等则返回true
    */
   public static boolean isEqual(String s1, String s2)
   {
      if(s1 == null && s2 == null)
         return true;
      else if(s1 != null)
         return s1.equals(s2);
      
      return false;
   }

   /**
    * 判断是否为整数
    * 
    * @param str 传入的字符串
    * @return 是整数返回true,否则返回false
    */
   public static boolean isInteger(String str)
   {
      java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("^[-\\+]?[\\d]*$");
      return pattern.matcher(str).matches();
   }

   /**
    * 判断是否为浮点数，包括double和float
    * 
    * @param str 传入的字符串
    * @return 是浮点数返回true,否则返回false
    */
   public static boolean isDouble(String str)
   {
      java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("^[-\\+]?[.\\d]*$");
      return pattern.matcher(str).matches();
   }

   /**
    * 判断是否为数字
    * 
    * @param value
    * @return
    */
   public static boolean isNumber(String value)
   {
      try
      {
         Double.valueOf(value);
         return true;
      }
      catch(Exception e)
      {
         return false;
      }
   }

   /**
    * 判断字符串是否为纯数字类型
    * 
    * @param str 源字符串
    * @return
    */
   public static boolean isNumString(String str)
   {
      boolean result = false;
      String regex = "^[0123456789]+$";
      
      if(str.matches(regex))
         result = true;// 是数值
      
      return result;
   }

   /**
    * 判断输入的字符串是否为纯汉字
    * 
    * @param str 传入的字符窜
    * @return 如果是纯汉字返回true,否则返回false
    */
   public static boolean isChinese(String str)
   {
      java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("[\u0391-\uFFE5]+$");
      return pattern.matcher(str).matches();
   }

   /**
    * 判断是不是合法手机 handset 手机号码
    */
   public static boolean isHandset(String handset)
   {
      try
      {
         if(!handset.substring(0, 1).equals("1"))
            return false;
         if(handset == null || handset.length() != 11)
            return false;
         
         String check = "^[0123456789]+$";
         java.util.regex.Pattern regex = java.util.regex.Pattern.compile(check);
         java.util.regex.Matcher matcher = regex.matcher(handset);

         if(matcher.matches())
            return true;
         else
            return false;
      }
      catch(RuntimeException e)
      {
         return false;
      }
   }

   /**
    * 判断输入的字符串是否符合Email样式.
    * 
    * @param str 传入的字符串
    * @return 是Email样式返回true,否则返回false
    */
   public static boolean isEmail(String email)
   {
      try
      {
         if(email == null || email.length() < 1 || email.length() > 256)
            return false;

         String check = "^([0-9a-zA-Z]+[_.0-9a-zA-Z-]+)@([a-zA-Z0-9-]+[.])+([a-zA-Z]{2,3})$";
         java.util.regex.Pattern regex = java.util.regex.Pattern.compile(check);
         java.util.regex.Matcher matcher = regex.matcher(email);

         if(matcher.matches())
            return true;
         else
            return false;
      }
      catch(RuntimeException e)
      {
         return false;
      }
   }

}