CSDN博客

img weixin_36380516
博客专家

StringHelper--封转自己的字符串工具类

发表于2017/4/17 22:25:58  2762人阅读

分类: Javaweb

我们每次开发项目,都会有很多的关于字符串的处理,字符串的处理太常见了,无法避免,那么这时如果可以把常用的字符串处理封装成类,在以后的开发中应该会减少一些工作量,下面代码对一些常用的字符串处理进行了封装,如果遇上了其他的关于字符串处理可以不断加入进来。

现在已经实现的功能有:

1,判断一个字符串是否为 null 或 空串 或 空白,

2,判断一个字符串是否不是null且不是空串、不是空白,

3,判断一个字符串变量是否为 null,

4,判断一个字符串是否为 空串,

5,比较两个非空(不是null,不是空串、不是空白)字符串是否"相等",

6,比较两个字符串是否 "相等",

7,随机生成一个 32 位长度的 字符串( UUID ),

8,通过 SHA1 对字符串进行加密,

9,对 给定字符串 进行 md5 加密,(对密码进行加密使用)

10,检测邮箱合法性,

11,Double进行四舍五入,得到指定位数的小数,

12,根据Unicode编码完美的判断中文汉字和符号,

13,判断是否包含中文汉字,

14判断是否只有中文汉字,

15判断邮政编码.

代码有详细备注,不做说明。如下:

public final class StringHelper {
	
	/**
	 * 判断一个字符串是否为 null 或 空串 或 空白
	 * @param source 需要判断的字符串
	 * @return 当字符串为 null 或 为 空白、空串 时返回 true
	 */
	public static boolean empty( String source ) {
		return source == null || source.trim().isEmpty()  ;
	}
	
	/**
	 * 判断一个字符串是否不是null且不是空串、不是空白
	 * @param source 需要判断的字符串
	 * @return 当 字符串是不是null且不是空串也不是空白时返回 true
	 */
	public static boolean notEmpty( String source ) {
		return source != null && source.trim().length() > 0 ;
	}
	
	/**
	 * 判断一个字符串变量是否为 null
	 * @param source 需要判断的字符串
	 * @return 当 字符串变量 为 null 时返回 true
	 */
	public static boolean isNull( String source ) {
		return source == null ;
	}
	
	/**
	 * 判断一个字符串是否为 空串
	 * @param source 需要判断的字符串
	 * @return 当字符串中的值是 空串 或 空白 串时返回 true
	 */
	public static boolean emptyString( String source ) {
		return ( source != null ) && source.length() == source.trim().length() ;
	}
	
	/**
	 * 判断一个字符串是否为 空白 串
	 * @param source 需要判断的字符串
	 * @return 当字符串中的值是 空白 串时返回 true
	 */
	public static boolean blank( String source ){
		return ( source != null ) && source.length() > source.trim().length()  ;
	}
	
	/**
	 * 比较两个非空(不是null,不是空串、不是空白)字符串是否"相等"
	 * @param one 第一个需要比较的字符串
	 * @param theOther 另一个参与比较的字符串
	 * @return 当 两个字符串 都不为空串 且 内容完全一致 (剔除首尾空白后、大小写也一致)时返回 true
	 */
	public static boolean equals( String one , String theOther) {
		return equals(one, theOther,true,false);
	}
	
	/**
	 * 比较两个字符串是否 "相等"
	 * @param one 参与比较的第一个字符串
	 * @param theOther 参与比较的另一个字符串
	 * @param escapeSpace 是否需要剔除首尾空白 ( true 表示需要剔除首尾空白,false 表示不剔除 )
	 * @param ignoreCase 是否忽略大小写 ( true 表示忽略大小写 ,false 表示不忽略大小写 )
	 * @return
	 */
	public static boolean equals( String one , String theOther , boolean escapeSpace , boolean ignoreCase) {
		
		if( one == null || theOther == null ){
			return false ;
		}
		
		if( escapeSpace ){
			one = one.trim();
			theOther = theOther.trim();
		}
		
		return ignoreCase ? one.equalsIgnoreCase( theOther ) : one.equals( theOther ) ;
	}
	
	/**
	 * 随机生成一个 32 位长度的 字符串( UUID )
	 * @return
	 */
	public static String random(){
		UUID uuid = UUID.randomUUID();//36位长度(包含了 四个 - )
		String uuidString = uuid.toString();
		uuidString = uuidString.replace("-", "");
		uuidString = uuidString.toUpperCase();
		return uuidString;
	}
	
	/**
	 * 通过 SHA1 对字符串进行加密
	 * @param source
	 * @return
	 */
	public static String sha1(String source ){
		try{
			MessageDigest md = MessageDigest.getInstance("SHA1");
			BASE64Encoder encoder = new BASE64Encoder();
			return encoder.encode( md.digest( source.getBytes() ) );
		}catch(NoSuchAlgorithmException e){
			e.printStackTrace();
			return null;
		}
	}
	
	/**
	 * 对 给定字符串 进行 md5 加密
	 * @param source 待加密的字符串
	 * @return
	 */
	protected static String md524(String source ){
		try{
			MessageDigest md = MessageDigest.getInstance("MD5");
			BASE64Encoder encoder = new BASE64Encoder();
			return encoder.encode( md.digest(source.getBytes()) );
		}catch(NoSuchAlgorithmException e){
			e.printStackTrace();
			return null;
		}
	}
	
	/**
	 * 对字符串进行MD5加密
	 * @param source 需要加密的字符串
	 * @return 返回加密后的字符串
	 */
	public static final String MD5(String source){
		if(source != null){
			StringBuffer md5 = new StringBuffer();
			MessageDigest md = null;
			try{
				md = MessageDigest.getInstance("MD5");
				md.update(source.getBytes());
				byte[] mdBytes = md.digest();
				
				for(int i = 0;i < mdBytes.length;i++){
					int temp;
					if(mdBytes[i] < 0){
						temp = 256+mdBytes[i];
					}else{
						temp = mdBytes[i];
					}
					if(temp < 16){
						md5.append("0");
					}
					md5.append(Integer.toString(temp,16 ));
				}
			}catch(NoSuchAlgorithmException e){
				e.printStackTrace();
			}
			return md5.toString().toUpperCase();
		}
		return null;
	}
	/**
     * 检测邮箱合法性
     * 
     * @param email
     * @return
     */
    public static boolean isEmail(String email) {
        if ((email == null) || (email.trim().length() == 0)) {
            return false;
        }
        String regEx = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}$";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(email.trim().toLowerCase());
 
        return m.find();
    }

 
    /**
     * Double进行四舍五入
     * 
     * @param v
     * @param scale
     * @return
     */
    public static double getDouble(Double v, int scale) {
 
        if (scale < 0) {
            scale = 0;
        }
        BigDecimal b = new BigDecimal(v);
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
 
    /**
     * 得到指定位数的小数
     * @param v
     * @param scale
     * @return
     */
    public static String getDecimals(Double v, int scale) {
 
        return String.format("%." + String.valueOf(scale) + "f", v);
 
    }
    /**
     * 根据Unicode编码完美的判断中文汉字和符号
     * 
     * @param c
     * @return
     */
    private static boolean isChinese(char c) {
        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
        if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
                || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
                || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
                || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
                || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS
                || ub == Character.UnicodeBlock.GENERAL_PUNCTUATION) {
            return true;
        }
        return false;
    }
 
    /**
     * 判断是否包含中文汉字
     * 
     * @param strName
     * @return
     */
    public static boolean isChineseHave(String strName) {
        char[] ch = strName.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            char c = ch[i];
            if (isChinese(c)) {
                return true;
            }
        }
        return false;
    }
 
    /**
     * 判断是否只有中文汉字
     * 
     * @param strName
     * @return
     */
    public static boolean isChineseAll(String strName) {
        char[] ch = strName.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            char c = ch[i];
            if (!isChinese(c)) {
                return false;
            }
        }
        return true;
    }
 
    /**
     * 判断邮政编码
     * 
     * @param str
     * @return
     */
    public static boolean isCard(String str) {
        Pattern p = Pattern.compile("[1-9]\\d{5}(?!\\d)");
        Matcher m = p.matcher(str);
        return m.matches();
    }
 
}


6 0

相关博文

我的热门文章

img
取 消
img