【Java】字符串工具类

import android.annotation.SuppressLint;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtils {
    
    /**
     * 判断ip合法性
     */
    @SuppressLint("NewApi")
    public static boolean isMacthIp(String ip) {
        if (ip != null && !ip.isEmpty()) {
            // 定义正则表达式            
            String regex = "^(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|[1-9])\."
                    + "(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\."
                    + "(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\."
                    + "(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)$"; // 判断ip地址是否与正则表达式匹配            
            if (ip.matches(regex)) {           
                return true;            
            }
        }    
        return false;    
    }
    
    /**
     * 判断字符串是否为空
     */
    public static boolean isEmpty(String str){
        if (str==null || "".equals(str)){
            return true;
        }
        return false;
    }

    /**
     * 判断字符串是否为空(包括对"null")
     */
    public static boolean isNullOrEmpty(String str){
        if (str==null || "".equals(str) || "null".equals(str) ){
            return true;
        }
        return false;
    }

    
    /**
     * 判断字符串是否纯数字
     */
    public static boolean isDigital(String str){
        if (!isEmpty(str))
            return str.matches("[0-9]+");
        return false;
    }
    
    /**
     * 计算含有中文的字符串长度
     * @param value 字符串（支持含中文字符串）
     * @return
     */
    public static int length(String value) {
        int valueLength = 0;
        String chinese = "[u0391-uFFE5]";
        /* 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1 */
        for (int i = 0; i < value.length(); i++) {
            /* 获取一个字符 */
            String temp = value.substring(i, i + 1);
            /* 判断是否为中文字符 */
            if (temp.matches(chinese)) {
                /* 中文字符长度为2 */
                valueLength += 2;
            } else {
                /* 其他字符长度为1 */
                valueLength += 1;
            }
        }
        return valueLength;
    }
    
    /**
     * 字符串数组转换List<String>
     * @param items
     * @return
     */
    public static List<String> stringsToList(String[] items) {
        List<String> lists = new ArrayList<String>();
        for(int i=0; i<items.length; i++){
            lists.add(items[i]);
        }
        return lists;
    }

    /**
     * 字符串填充，将sour使用fillStr前补或后补满len长度
     * @param sour 待填充字符串，支持含有中文
     * @param fillStr 填充数据
      * @param len 填充完整字符串长度
     * @param isLeft 是否左补填充数据，否则右补填充数据
     * @return
     */
    public static String fill(String sour, String fillStr, int len, boolean isLeft){
        if (sour == null) {
            sour = "";
        }
        int fillLen = len - length(sour);
        String fill = "";
        for (int i=0; i<fillLen; i++) {
            fill = fill + fillStr;
        }
        if (isLeft) {
            return fill + sour;
        } else {
            return sour + fill;
        }
    }
    
    /**
     * 字符串填充，中间填充
     * @param sour 左侧待填充字符串，支持含有中文
     * @param space 填充的数据，一般为* 、空格、——
     * @param lengh 填充完整字符串长度
     * @param modelparams 右侧待填充字符串，支持含有中文
     * @return
     */
    public static String fillMiddle(String sour, String space, int lengh, String modelparams){
        String s, ss = null;
        int lenS = sour.length();
        int lenM = modelparams.length();
        //做非空处理
        if(sour == null) {
            sour = "";
        }
        if(modelparams == null) {
            modelparams = "";
        }
        if (space == "") {
            space = " "; 
        }
        //若输入为汉字，则长度取2倍
        if (sour.matches("[u4e00-u9fa5]+")) {
            lenS = lenS*2;
        }
        if (modelparams.matches("[u4e00-u9fa5]+")) {
            lenM = lenM*2;
        }
        //若输入有数字则，总长度加3
        if (sour.matches("[0-9]") && modelparams.matches("[0-9]")) {
            lengh = lengh + 4;
        }
        //长度保护
        if (lengh < (lenS + lenM)) {
            new Exception("哥们，长度设置太小了");
        }
        
        s = fill(modelparams, space, lengh - lenS-lenM, true);
        ss = sour + s +"
";
        
        return ss;
    }
    
    
    /**
     * 字符串填充
     * 
     * @param strData 待填充字符串，不支持含有中文
     * @param nLen
     * @param
     * @param nOption
     *            0:左侧填充; 1:右侧填充; 2:两边填充
     * @return
     */
    public static String paddingString(String strData, int nLen, String subStr,
                                       int nOption) {
        int i, addCharLen;

        String strHead = "";
        String strEnd = "";

        i = strData.length();
        if (i >= nLen) {
            return strData;
        }

        switch (nOption) {
        case 0:
            addCharLen = (nLen - i) / subStr.length();
            for (i = 0; i < addCharLen; i++) {
                strHead += subStr;
            }
            return strHead + strData;
        case 1:
            addCharLen = (nLen - i) / subStr.length();
            for (i = 0; i < addCharLen; i++) {
                strEnd += subStr;
            }
            return strData + strEnd;
        case 2:
            addCharLen = (nLen - i) / (subStr.length() * 2);
            for (i = 0; i < addCharLen; i++) {
                strHead += subStr;
                strEnd += subStr;
            }
            return strHead + strData + strEnd;
        default:
            return strData;
        }
    }

    /**
     * 整形转换成BCD型的字符串
     * 9转换成后将变成09,00 09
     * 19转换后将变成19, 00 19
     * @param value
     * @param bytesNum
     *            BCD字节个数
     * @return
     */
    public static String intToBcd(int value, int bytesNum) {
        switch(bytesNum){
        case 1:
            if (value >= 0  && value <= 99){
                return paddingString(String.valueOf(value),2,"0",0);
            }
            break;
        case 2:
            if (value >= 0  && value <= 999) {
                return paddingString(String.valueOf(value),4,"0",0);
            }
            break;
            
        case 3:
            if (value >= 0  && value <= 999) {
                return paddingString(String.valueOf(value),3,"0",0);
            }
            break;
        }
        
        return "";
    }

    /**
     * Hex数据转换成字符串
     * 
     * @param value
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String hexToStr(String value) throws UnsupportedEncodingException {
        return new String(BytesUtils.hexToBytes(value),"GBK");
    }
    /**
     * Hex数据转换成字符串
     * encoding 为编码
     * @param value 
     * @return
     * @throws UnsupportedEncodingException
     */
    public static String hexToStr(String value, String encoding) throws UnsupportedEncodingException {
        return new String(BytesUtils.hexToBytes(value),encoding);
    }

    /**
     * 字符串转换成Hex
     * 
     * @param value
     * @return
     */
    public static String strToHex(String value) {
        return BytesUtils.bytesToHex(BytesUtils.getBytes(value));
    }

    /**
     * 往value中填充一个字符0 ,当数据长度正好为2的整数倍时，不填充
     * 
     * @param value
     * @param option
     *            0:往后填充 ;1:往前填充
     * @return
     */
    public static String paddingZeroToHexStr(String value, int option) {
        
        if (value.length() % 2 == 0){
            return value;
        }
        
        if (option == 0){
            return "0" + value;
        }
        else if (option == 1){
            return value + "0";
        }
        else{
            return value;
        }
    }

    /**
     * 判断是否是Hex格式数据
     * 
     * @param value
     * @return
     */
    public static boolean checkHexStr(String value) {
        int i;
        int len;
        
        if (value == null) return false;
        
        len = value.length();
        if (len == 0) return false;

      for (i= 0;i<len;i++){
          if (!((value.charAt(i) >= '0' && value.charAt(i) <= '9')|| 
                  (value.charAt(i) >= 'a' && value.charAt(i) <= 'f') ||
                  (value.charAt(i) >= 'A' && value.charAt(i) <= 'F'))){
              return false;               
          }
      }
      return true;
    }

    /**
     * 判断字符串是否是数字0-9
     * 
     * @param value
     * @return
     */
/*    public static boolean checkDigitStr(String value) {
        int i;
        int len;
        
        if (value == null) return false;
        
        len = value.length();
        if (len == 0) return false;

      for (i= 0;i<len;i++){
          if (value.charAt(i) < '0' || value.charAt(i) > '9') {
              return false;               
          }
      }
      return true;
    }*/
    
    /**
     * Binary数据转换成Hex
     * 
     * @param value
     * @return
     */
    public static String binaryToHex(String value) {
        int i,j,len;
        String result ="";
        char[] hexVocable = { '0', '1', '2', '3', 
                '4', '5', '6','7', 
                '8', '9', 'A', 'B', 
                'C', 'D', 'E', 'F' };
        String[] binString  = {"0000", "0001", "0010", "0011",
                "0100", "0101", "0110", "0111",
                "1000", "1001", "1010", "1011",
                "1100", "1101", "1110", "1111"};
        //System.out.println("value: " + value);
        
        len = value.length();
        for(i=0; i<len; i += 4){
            for(j=0; j<16; j++){
                if(binString[j].equals(value.substring(i, i+4))){
                    result += hexVocable[j];
                    break;
                }                
            }
        }
        //System.out.println("result: " + result);
        return result;
    }

    /**
     * Hex数据转换成Binary
     * 
     * @param value
     * @return
     */
    public static String hexToBinary(String value) {
        int i,j,len;
        String result ="";
        char[] hexVocable = { '0', '1', '2', '3', 
                '4', '5', '6','7', 
                '8', '9', 'A', 'B', 
                'C', 'D', 'E', 'F' };
        String[] binString  = {"0000", "0001", "0010", "0011",
                "0100", "0101", "0110", "0111",
                "1000", "1001", "1010", "1011",
                "1100", "1101", "1110", "1111"};
        
        len = value.length();
        for(i=0; i<len; i++){
            for(j=0; j<16; j++){
                if(value.charAt(i) == hexVocable[j]){
                    result += binString[j];
                    break;
                }                
            }
        }
        //System.out.println("result: " + result);
        return result;
    }
    
    /**
     * 获取二进制字符串
     * 0x00 0x01 0x00 0x01 0x01转换成"01011"
     * @param value
     * @return
     */
    public static String getBinaryString(byte[] value) {
        int len;
        String result ="";
        
        len = value.length;
        
        for(int i=0;i<len;i++) {
            result += String.valueOf(value[i]);
        }
        
        return result;
    }
    /**
     * mmdd日期格式
     * @param date
     * @return
     */
    public static boolean isMatchDate(String date){
        if(date.length()!=4||date==null){
            return false;
        }
        String eL="(((0[13578]|1[02])(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)(0[1-9]|[12][0-9]|30))|(02(0[1-9]|[1][0-9]|2[0-9])))";
           Pattern p = Pattern.compile(eL);
            Matcher m = p.matcher(date);
            boolean b = m.matches();   
            return b;
    }
    
    /**
     * 删除字符串左侧所有字符ch
     * @param
     * @return
     */
    public static String deleteLeftChar(String data, char ch){
        int flag = 0;
        for(int i = 0;i<data.length();i++){
            if(data.charAt(i) == ch){
                flag = i;
            }else{
                break;
            }
        }
        flag = flag+1;
        data = data.substring(flag);
        return data;
    }
    
    /**
     * 删除字符串右侧所有字符ch
     * @param
     * @return
     */
    public static String deleteRightChar(String data, char ch){
        
        int flag = data.length();
        for(int i = data.length()-1;i>=0;i--){
            if(data.charAt(i) == ch){
                flag = i;
            }else{
                break;
            }
        }

        data = data.substring(0,flag);
        return data;
    }
    
    
        /**
     * 将显示金额的字符串（带原点），转化为没有原点的字符串
     * 
     * 示例：123.32 --->  12332
     *       2.  ----> 200
     *       2.3  ----> 230
     *       0.12 --->  12
     *       0.02 --->   2
     * @param str
     * @return
     */
    public static String decimalWipeDot(String str){
        
        //拿到字符串
        if (str.contains(".")) {
            
            //判断点后还有几位
            int indexOf = str.indexOf(".");
            //用索引和长度进行判断
            int length = str.length();
            int cha = length - indexOf; 
            char charAt = str.charAt(indexOf - 1);

            switch (cha) {
            case 1:
                //小数后有0位--先去掉点，在加个00   eg: 2. --> 200   0.-->0
                if (charAt == '0') {
                    str= "0";
                }else {
                    str = str.replace(".", "");
                    str= str+"00";
                }
                break;
            case 2:
                //小数后有1位--先去掉点，在加个0  eg: 2.3 -->  230  0.1 -->10
                if (charAt == '0') {
                    str= str.charAt(indexOf + 1)+"0";
                }else {
                    str = str.replace(".", "");
                    str= str+"0";
                }
                
                break;
            case 3:
                //小数后有2位--直接去掉点   eg:   2.03 --> 203   0.12-->12  0.02 --> 2
                char charAt2 = str.charAt(indexOf + 1);
                if (str.length() == 4) {
                    
                    if (charAt == '0') {
                        if (charAt2 == '0') {
                            str= str.substring(length - 1,length);
                        }else {
                            
                            str= str.substring(indexOf + 1,length);
                        }
                    }else {
                        str = str.replace(".", "");
                    }
                }else {
                    str = str.replace(".", "");
                }
                
                break;
            default:
                break;
            }
        }else {
            //没有点， 直接加00  eg:  23 ---> 2300   0--->0   0000023--->  2300    00000--->0
            //去掉前面多余的0 ，在判断这个数是否为0
            if (str.equals("")) {
                str = "0";
            }
            int int1 = Integer.parseInt(str);
            str = String.valueOf(int1);
            
            if (int1 != 0){
                str = str+"00";
            }else {
                str = "0";
            }
        }
        return str;
    }
    
    /**
     * 将金额的字符串(不带点)  转化为带点的金额字符串
     * 示例       12332 ---> 123.32
     *       200   --->  2
     *       230   ----> 2.3 
     *        12 ---> 0.12 
     *         2  ---> 0.02
     * 
     * 
     * @param str
     * @return
     */
    public static String decimalAddDot(String str){
        boolean isNegative = false;
        str = str.replace(" ","");

        if (str == null || str == "") {
            return "0.00";
        }
        //截取字符第一个字符
         String sign = str.substring(0,1);
        if (sign.equals("-")) {
            isNegative = true;//标记为负数
            str = str.substring(1,str.length());
        }else{
            //正数不作处理
        }

        int length = str.length();
        if (length >= 3) {  //200-->2.00
            str = str.substring(0, length-2)+"."+str.substring(length-2, length);
        }else {
            switch (length) {
            case 2:// 20-->0.20   23 --> 0.23
                str = "0."+str;
                break;
            case 1://  2-->0.02   
                str = "0.0"+str;
                break;
            case 0:
                //说明没有    0.00
                str = "0.00";
                break;
            default:
                break;
            }
        }

        if (isNegative) {
            return "-"+str;
        }else{
            return str;
        }

    
        
    }
}