java 其他 公共方法

 //随机码字典集
        private static final String RANDOM_STR="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    
/**
     * 验证某一字符串是不是   null or ""
     * @param src 验证的字符串
     * @return true or false
     */
    public static boolean validateBlank(String src){
        return (src == null) || src.trim().equals("") ;
    }
    /**
     * 验证是不是合法email
     * @param email 验证的email
     * @return
     */
    public static boolean validateEmail(String email){
        String regex = "^([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})$";
        if(!validateBlank(email)){
            return Pattern.compile(regex).matcher(email).matches();
        }else{
            return false;
        }
    }
    /**
     * 验证是不是合法的手机号
     * @param phone 验证的手机号
     */
    public static boolean validatePhone(String phone){
        String regex = "^1([3-8]){1}\\d{9}$";
        if(!validateBlank(phone)){
            return Pattern.compile(regex).matcher(phone).matches();
        }else{
            return false;
        }
    }
    /**
     * 验证是不是合法的固话
     * @param tel 验证的固话
     * @return
     */
    public static boolean validateTel(String tel){
        String regex = "^(0[0-9]{2,3}\\-)?([2-9][0-9]{6,7})+(\\-[0-9]{1,4})?$";
        if(!validateBlank(tel)){
            return Pattern.compile(regex).matcher(tel).matches();
        }else{
            return false;
        }
    }
    /**
     * 验证是不是合法的邮编
     * @param postCode 验证的邮编
     * @return
     */
    public static boolean validatePostCode(String postCode){
        String regex = "^\\d{6}$";
        if(!validateBlank(postCode)){
            return Pattern.compile(regex).matcher(postCode).matches();
        }else{
            return false;
        }
    }
    /**
     * 验证中文汉字
     * @param chinese 验证的字符
     * @param min 最低
     * @param max 最多
     * @return
     */
    public static boolean validateChinese(String chinese,int min,int max){
        String regex = "^[\u4E00-\u9FA5\uf900-\ufa2d]{"+min+","+max+"}$";
        if(!validateBlank(chinese)){
            return Pattern.compile(regex).matcher(chinese).matches();
        }else{
            return false;
        }
    }
    /**
     * 验证英文字符串
     * @param name 验证的字符
     * @param min 最低
     * @param max 最多
     * @return
     */
    public static boolean validateWorld(String name,int min,int max){
        String regex = "^\\w{"+min+","+max+"}$";
        if(!validateBlank(name)){
            return Pattern.compile(regex).matcher(name).matches();
        }else{
            return false;
        }
    }
    /**
     * 验证是不是常见图片格式
     * @param name
     * @return
     */
    public static boolean ValidateImage(String name){
        String regex = "^(.*)\\.(jpg|png|bmp|jpeg)$";
        if(!validateBlank(name)){
            name = name.trim().toLowerCase();
            return Pattern.compile(regex).matcher(name).matches();
        }else{
            return false;
        }
    }
    /**
     * text文件
     * @param name
     * @return
     */
    public static boolean ValidateText(String name){
        String regex = "^(.*)\\.(txt)$";
        if(!validateBlank(name)){
            name = name.trim().toLowerCase();
            return Pattern.compile(regex).matcher(name).matches();
        }else{
            return false;
        }
    }
    /**
     * doc文件
     * 判断是否为word文件
     */
    public static boolean ValidateDoc(String name){
        String regex = "^(.*)\\.(doc|docx)$";
        if(!validateBlank(name)){
            name = name.trim().toLowerCase();
            return Pattern.compile(regex).matcher(name).matches();
        }else{
            return false;
        }
    }
    /**
     * 判断是否为excel
     * @param str
     * @return
     */
    public static boolean ValidateExcel(String str){
        String regEx4="^(.*)\\.(xls|xlsx)$";
        boolean flag=false;
        if(!validateBlank(str)){
            for(int i=0;i<str.length();i++){
                flag=Pattern.compile(regEx4).matcher(str.trim().toLowerCase()).matches();
                if(flag==false){
                    break;
                }
            }
        }
        return flag;
    }
    /**
     * 验证是否为数字
     * @date 2016年4月20日 下午7:04:08
     * @param str
     * @return
     */
    public static boolean validateDouble(String str){
        //^[1-9]+[0-9]*(.?)[0-9]+$|^[0-9]$|^0.[0-9]+$
        String reg = "[1-9]+[0-9]*(.?)[0-9]+$|[0-9]|0.[0-9]+";
        if(!validateBlank(str)){
            return Pattern.compile(reg).matcher(str.trim()).matches();
        }else{
            return false;
        }
    }
    /**
     * 验证是否为正整数
     * @date 2016年4月21日 上午8:42:31
     * @param str
     * @return
     */
    public static boolean validateInteger(String str){
        String reg = "[^0][0-9]+|[0-9]";
        if(!validateBlank(str)){
            return Pattern.compile(reg).matcher(str.trim()).matches();
        }else{
            return false;
        }
    }
    /**
    	 * 取某个范围的任意数
    	 * @param min
    	 * @param max
    	 * @return
    	 */
    	public static int getNext(int min, int max) {
    		Random random = new Random();
    		int s = random.nextInt(max) % (max - min + 1) + min;
    		return s;
    	}
    	
    	/**
    	 * 取某个范围的任意数
    	 * @param min
    	 * @param max
    	 * @return
    	 */
    	public static int getNext(int max) {
    		Random random = new Random();
    		int s = random.nextInt(max) ;
    		return s;
    	}
    	
    	/**
    	 * 生成sum位随机码
    	 * @return
    	 */
    	public static String generateDigitRandomCode(int sum){
    		Random rd = new Random();
    		String n = "";
    		int getNum;
    		do {
    			getNum = Math.abs(rd.nextInt(Integer.MAX_VALUE)) % 10 + 48;// 产生数字0-9的随机数
    			char num1 = (char) getNum;
    			String dn = Character.toString(num1);
    			n += dn;
    		} while (n.length() < sum);
    
    		return n;
    	}
    	
    	/**
    	 * 生成sum位数字字母随机码
    	 * @param sum
    	 * @return
    	 */
    	public static String generateMixRandomCode(int sum){  
            Random random = new Random();  
            StringBuffer sb = new StringBuffer();  
              
            for(int i = 0 ; i < sum; ++i){  
                int number = random.nextInt(62);//[0,62)  
                  
                sb.append(RANDOM_STR.charAt(number));  
            }  
            return sb.toString();  
        }  
    	
    	/**
    	 * IP 地址转换成 long 数据
    	 * @param ipAddress
    	 * @return
    	 */
    	public static long ipAddressToLong(String ipAddress) {
    		long ipInt = 0;
    		if (ValidatorUtil.isIPv4Address(ipAddress)) {
    			String[] ipArr = ipAddress.split("\\.");
    			if (ipArr.length == 3) {
    				ipAddress = ipAddress + ".0";
    			}
    			ipArr = ipAddress.split("\\.");
    			long p1 = Long.parseLong(ipArr[0]) * 256 * 256 * 256;
    			long p2 = Long.parseLong(ipArr[1]) * 256 * 256;
    			long p3 = Long.parseLong(ipArr[2]) * 256;
    			long p4 = Long.parseLong(ipArr[3]);
    			ipInt = p1 + p2 + p3 + p4;
    		}
    		return ipInt;
    	}
    
    /**
    	 * 判断字符串是否为null、“ ”、“null”
    	 * @param obj
    	 * @return
    	 */
    	public static boolean isNull(String obj) {
    		if (obj == null){
    			return true;
    		}else if (obj.toString().trim().equals("")){
    			return true;
    		}else if(obj.toString().trim().toLowerCase().equals("null")){
    			return true;
    		}
    		
    		return false;
    	}
    
    	/**
    	 * 正则验证是否是数字
    	 * @param str
    	 * @return
    	 */
    	public static boolean isNumber(String str) {
    		Pattern pattern = Pattern.compile("[+-]?[0-9]+[0-9]*(\\.[0-9]+)?");
    		Matcher match = pattern.matcher(str);
    		
    		return match.matches();
    	}
    
    /**
    	 * 功能：手机号验证
    	 * 
    	 * @param str
    	 * @return
    	 */
    	public static boolean isMobile(String str) {
    		Pattern p = null;
    		Matcher m = null;
    		boolean b = false;
    		if (StringUtils.isBlank(str)) {
    			return b;
    		}
    		p = Pattern.compile("^[1][3,4,5,8][0-9]{9}$"); // 验证手机号
    		m = p.matcher(str);
    		b = m.matches();
    		return b;
    	}
    
    	/**
    	 * 功能：数字判断
    	 * @param str
    	 * @return
    	 */
    	public static boolean isNumeric(String str) {
    		if (StringUtils.isBlank(str)) {
    			return false;
    		}
    		
    		if (str.matches("\\d*")) {
    			return true;
    		} else {
    			return false;
    		}
    	}
    	
    	/**
    	 * 判断密码格式是否正确(只能是数组或者字母，并存长度为[6,12])
    	 * @param passwd
    	 * @return
    	 * @author wyongjian
    	 * @date 2014-11-18
    	 */
    	public static boolean isPasswd(String passwd){
    		if(StringUtils.isBlank(passwd))return false;
    		if(passwd.length()<6 || passwd.length()>12)return false;
    		String regEx="^[A-Za-z0-9_]+$";
    	    Pattern p=Pattern.compile(regEx);
    	    Matcher m=p.matcher(passwd);
    	    return m.matches();
    	}
    	
    	/**
    	 * 判断是否是IPv4
    	 * @param input
    	 * @return
    	 */
    	public static boolean isIPv4Address(String input) {
    		Pattern IPV4_PATTERN = Pattern
    				.compile("^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$");
    		return IPV4_PATTERN.matcher(input).matches();
    	}
    	
    	/**
    	 * 判断是否是MAC地址
    	 * @param mac
    	 * @return
    	 * @author wyongjian
    	 * @date 2014-11-26
    	 */
    	public static boolean isMac(String mac){
    		if(StringUtils.isNotBlank(mac)){
    			mac = mac.toUpperCase();
    			
    			//正则校验MAC合法性  
    		    String patternMac="^[A-F0-9]{2}(:[A-F0-9]{2}){5}$";  
    		    if(Pattern.compile(patternMac).matcher(mac).find()){  
    		    	return true;
    	        } 
    		}
    	    return false;
    	}
    
    	/**
    	 * 判断用户名格式是否正确(只能是数组、字母或者下划线)
    	 * @param username
    	 * @return
    	 */
    	public static boolean isUsername(String username){
    		if(StringUtils.isBlank(username))return false;
    		String regEx="^[A-Za-z0-9_]+$";
    	    Pattern p=Pattern.compile(regEx);
    	    Matcher m=p.matcher(username);
    	    return m.matches();
    	}
    	
    	/**
    	 * 字符串是否包含中文
    	 * @param source
    	 * @return
    	 */
    	public static boolean isContainsChinese(String source){
    		final String regEx = "[\u4e00-\u9fa5]";
    		final Pattern pat = Pattern.compile(regEx);
    		boolean flag = false;
    		Matcher matcher = pat.matcher(source);
    		if(matcher.find()) {
    			flag = true;
    		}
    		return flag;
    	}
    	
    	public static boolean isEmail(String email){
    		
    //		final String regEx="/[^@]+@[^@]/";
    		final String regEx="^([a-z0-9A-Z]+[-|_|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
    		final Pattern pat = Pattern.compile(regEx);
    		boolean flag = false;
    		Matcher matcher = pat.matcher(email);
    		flag = matcher.matches();
    		
    		return flag;
    	}
    
    /**
         * 生成指定范围的随机整数
         * @param min
         * @param max
         * @return
         */
        public static int randomRange(final int min,final int max){
            Random random = new Random();
            return random.nextInt(max)%(max-min+1) + min;
        }
    
    
    
    
    /**
         * @param imgData base64编码字符串
         * @Description: 将base64编码字符串转换为图片
         */
        public static byte[] generateImage(String imgData) {
            if (imgData == null){
                return null;
            }
            imgData = imgData.substring(imgData.indexOf(',')+1);
            BASE64Decoder decoder = new BASE64Decoder();
            try {
                // 解密
                byte[] b = decoder.decodeBuffer(imgData);
                // 处理数据
                for (int i = 0; i < b.length; ++i) {
                    if (b[i] < 0) {
                        b[i] += 256;
                    }
                }
                return b;
            } catch (Exception e) {
                log.error(e.getMessage());
            }
            return null;
        }
    
    //匹配Long型的Date
    Pattern p = Pattern.compile("^(\\-|\\+)?\\d{13,}$");
    Matcher m = p.matcher("-8551958400000");
    System.out.println(m.matches());
    
    
    //手机号处理
    phone = phone.replaceAll("(\\d{3})\\d{4}(\\d{4})","$1****$2");//原始数据:15360123509     处理后:153****3509 
    		//身份证号处理
    		idCard = idCard.replaceAll("(\\d{4})\\d{10}(\\w{4})","$1*****$2"); //18位身份证  原始数据:身份证号  处理后:4304*****7733
    		idCard = idCard.replaceAll("(\\d{3})\\d{10}(\\w{2})","$1*****$2"); //15位身份证  原始数据:身份证号  处理后:141*****80
    		System.out.println(phone);
    		System.out.println(idCard);