【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 +"\n";
        
        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;
        }

    
        
    }
}