工具类之——StringUtils 有更新!

  |   0 评论   |   255 浏览

    有时候根据实际需求,要将数据进行一定的格式转换,在这里提供一个实际开发中使用的一个工具类,工具类中方法会持续更新

    package top.wys.developerclub.utils;
    /**
     * @author 郑明亮
     * @Time:2016年12月22日 上午11:04:44
     * @Description 字符串相关工具类
     */
    public class StringUtils {
    
        private StringUtils() {
            throw new UnsupportedOperationException("Can not be instantiated...");
        }
    
    /**
     * @author 郑明亮
     * @Time 2017年1月23日 上午9:58:07
     * @Description <p> 将Unicode编码的文本进行解码</p>
     * @param str Unicode编码文本
     * @return 解码后的文本
     */
    public static String unicodeToString(String str) {
     
        Pattern pattern = Pattern.compile("(\\\\u(\\p{XDigit}{4}))");    
        Matcher matcher = pattern.matcher(str);
        char ch;
        while (matcher.find()) {
            ch = (char) Integer.parseInt(matcher.group(2), 16);
            str = str.replace(matcher.group(1), ch + "");    
        }
        return str;
    }
    
    /**
     * @author 郑明亮
     * @Time 2017年1月23日 上午9:57:20
     * @Description <p>将中文转换为Unicode编码   </p>
     * @param s 想要进行编码的文本
     * @return Unicode编码 文本
     */
    public static String getUnicode(String s) {
        try {
            StringBuffer out = new StringBuffer("");
            byte[] bytes = s.getBytes("unicode");
            for (int i = 0; i < bytes.length - 1; i += 2) {
                out.append("\\u");
                String str = Integer.toHexString(bytes[i + 1] & 0xff);
                for (int j = str.length(); j < 2; j++) {
                    out.append("0");
                }
                String str1 = Integer.toHexString(bytes[i] & 0xff);
                out.append(str1);
                out.append(str);
                 
            }
            return out.toString();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }
    
        /**
         * 判断字符串是否为null或长度为0
         *
         * @param s 待校验字符串
         * @return {@code true}: 空<br> {@code false}: 不为空
         */
        public static boolean isEmpty(CharSequence s) {
            return s == null || s.length() == 0;
        }
    
        /**
         * 判断字符串是否为null或全为空格
         *
         * @param s 待校验字符串
         * @return {@code true}: null或全空格<br> {@code false}: 不为null且不全空格
         */
        public static boolean isSpace(String s) {
            return (s == null || s.trim().length() == 0);
        }
    
        /**
         * 判断两字符串是否相等
         *
         * @param a 待校验字符串a
         * @param b 待校验字符串b
         * @return {@code true}: 相等<br>{@code false}: 不相等
         */
        public static boolean equals(CharSequence a, CharSequence b) {
            if (a == b) return true;
            int length;
            if (a != null && b != null && (length = a.length()) == b.length()) {
                if (a instanceof String && b instanceof String) {
                    return a.equals(b);
                } else {
                    for (int i = 0; i < length; i++) {
                        if (a.charAt(i) != b.charAt(i)) return false;
                    }
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 判断两字符串忽略大小写是否相等
         *
         * @param a 待校验字符串a
         * @param b 待校验字符串b
         * @return {@code true}: 相等<br>{@code false}: 不相等
         */
        public static boolean equalsIgnoreCase(String a, String b) {
            return (a == b) || (b != null) && (a.length() == b.length()) && a.regionMatches(true, 0, b, 0, b.length());
        }
    
        /**
         * null转为长度为0的字符串
         *
         * @param s 待转字符串
         * @return s为null转为长度为0字符串,否则不改变
         */
        public static String null2Length0(String s) {
            return s == null ? "" : s;
        }
    
        /**
         * 返回字符串长度
         *
         * @param s 字符串
         * @return null返回0,其他返回自身长度
         */
        public static int length(CharSequence s) {
            return s == null ? 0 : s.length();
        }
    
        /**
         * 首字母大写
         *
         * @param s 待转字符串
         * @return 首字母大写字符串
         */
        public static String upperFirstLetter(String s) {
            if (isEmpty(s) || !Character.isLowerCase(s.charAt(0))) return s;
            return String.valueOf((char) (s.charAt(0) - 32)) + s.substring(1);
        }
    
        /**
         * 首字母小写
         *
         * @param s 待转字符串
         * @return 首字母小写字符串
         */
        public static String lowerFirstLetter(String s) {
            if (isEmpty(s) || !Character.isUpperCase(s.charAt(0))) return s;
            return String.valueOf((char) (s.charAt(0) + 32)) + s.substring(1);
        }
    
        /**
         * 反转字符串
         *
         * @param s 待反转字符串
         * @return 反转字符串
         */
        public static String reverse(String s) {
            int len = length(s);
            if (len <= 1) return s;
            int mid = len >> 1;
            char[] chars = s.toCharArray();
            char c;
            for (int i = 0; i < mid; ++i) {
                c = chars[i];
                chars[i] = chars[len - i - 1];
                chars[len - i - 1] = c;
            }
            return new String(chars);
        }
    
        /**
         * 转化为半角字符
         *
         * @param s 待转字符串
         * @return 半角字符串
         */
        public static String toDBC(String s) {
            if (isEmpty(s)) return s;
            char[] chars = s.toCharArray();
            for (int i = 0, len = chars.length; i < len; i++) {
                if (chars[i] == 12288) {
                    chars[i] = ' ';
                } else if (65281 <= chars[i] && chars[i] <= 65374) {
                    chars[i] = (char) (chars[i] - 65248);
                } else {
                    chars[i] = chars[i];
                }
            }
            return new String(chars);
        }
    
        /**
         * 转化为全角字符
         *
         * @param s 待转字符串
         * @return 全角字符串
         */
        public static String toSBC(String s) {
            if (isEmpty(s)) return s;
            char[] chars = s.toCharArray();
            for (int i = 0, len = chars.length; i < len; i++) {
                if (chars[i] == ' ') {
                    chars[i] = (char) 12288;
                } else if (33 <= chars[i] && chars[i] <= 126) {
                    chars[i] = (char) (chars[i] + 65248);
                } else {
                    chars[i] = chars[i];
                }
            }
            return new String(chars);
        }
        
        /**
    	 * @author 郑明亮
    	 * @Time 2017年1月12日 下午1:16:39
    	 * @Description <p>去掉浮点类型的小数点,并进行四舍五入   </p>
    	 * 				<p>应用场景:将浮点型转换为整型数据,并保留1位小数</p>
    	 * @param amountString 浮点型金额字符串
    	 * @return 整型数字符串
    	 */
    	public static String removeAmountPoint(String amountString){
    		String noPointString = "";
    		if (amountString == null) {
    			return noPointString;
    		}else{
    			Integer amount;
    			if (amountString.indexOf("." )!= -1) {
    				String pointNum =  amountString.substring(amountString.indexOf("." ));
    				amount  = Integer.parseInt(amountString.replace(pointNum, ""));
    				if (pointNum.length()>2) {
    					int num = Integer.parseInt(pointNum.substring(1, 2));
    					if (num >=5) {
    						amount ++;
    						
    					}
    				}
    				noPointString = ""+amount;
    			}else {
    				return amountString;
    			}
    			return noPointString;
    		}
    			
    	}
    /**
    	 * @author 郑明亮
    	 * @Time 2017年1月13日 下午4:18:14
    	 @param amount 金额
    	 * @param pattern 将数字转换为指定格式    {@value AmountPattern}
    	 * <p>如 amount: 10000000  ,当传入金额为null时,默认为0 </p>
    	 * <p>如 pattern:  \u00A5,###.00 ,当pattern为null时,使用默认pattern ,即"\u00A5,##0.00" </p>
    	 * <p>如 return: ¥10,000,000   </p>
    	 * @return 格式化后的数字字符串
    	 * @throws ParseException
    	 */
    	public static String formateAmount(Object amount,String pattern) throws ParseException{
    		if (amount == null) {//当传入金额为null时,默认为0
    			return formateAmount(0,pattern);
    		}
    		if (pattern == null) {//当pattern为null时,使用默认pattern
    			pattern = "\u00A5,##0.00";
    		}
    		if (amount instanceof String) {
    			return formateAmount(Double.parseDouble(amount.toString()),pattern);
    		}
    		DecimalFormat format = new DecimalFormat(pattern);
    		String number = format.format(amount);
    		return number;
    	}
    }

     

     

     

     

     

    评论

    发表评论

    validate