日常的工具类

package com.xxx.ccc.bzb.util;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sf.json.JSONObject;

import org.apache.commons.lang.StringUtils;

/**
 * 日常工具类
 *
 */
public class CommonUtils {
	
	private static final String regEx_script = "<script[^>]*?>[\\s\\S]*?<\\/script>"; // 定义script的正则表达式
    private static final String regEx_style = "<style[^>]*?>[\\s\\S]*?<\\/style>"; // 定义style的正则表达式
    private static final String regEx_html = "<[^>]+>"; // 定义HTML标签的正则表达式
    private static final String regEx_space = "\\s*|\t|\r|\n";//定义空格回车换行符
    
    /**
     * 如果字符串str超过cut位，超过部分将被截取掉，替换为rep
     * 
   
     * @return String
     */
    public static String subCutIfOver(String str,int cut,String rep){
    	if(StringUtils.isNotBlank(str)){
    		int length = str.length();
    		if(length>cut){
    			str = str.substring(0, cut);
    			if(StringUtils.isNotBlank(rep)){
    				str += rep;
    			}
    		}
    	}
    	return str;
    }
    
    /**
     * String转Int
     * 

     */
    public static int getInt(String intStr,int defaultValue){
    	int result = defaultValue;
    	try {
			result = Integer.parseInt(intStr);
		} catch (Exception e) {
		}
		return result;
    }
    
    /**
     * String转Double
    
     */
    public static double getDouble(String intStr,double defaultValue){
    	double result = defaultValue;
    	try {
			result = Double.parseDouble(intStr);
		} catch (Exception e) {
		}
		return result;
    }
	
	/**
	 * @Description: TODO(获取UUID)

	 */
	public static String getUUID() {
		String s = UUID.randomUUID().toString();
		// 去掉“-”符号
		return s.substring(0, 8) + s.substring(9, 13) + s.substring(14, 18) + s.substring(19, 23) + s.substring(24);
	}
	
	/**
	 * @Title: arrToList
	 * @Description: 将String[]转化为List
	 * @param arr
	 * @return 设定文件
	 * @return List<String> 返回类型 返回格式
	
	 */
	public static List<String> arrToList(String[] arr) {
		List<String> list = null;
		if (arr != null && arr.length > 0) {
			list = new ArrayList<String>();
			for (int i = 0; i < arr.length; i++) {
				if(StringUtils.isNotBlank(arr[i])){
					list.add(arr[i]);
				}
			}
		}
		return list;
	}
	
	/**
	 * @Title: listToArr
	 * @Description: 将List转化为String[]
	 * @param arr
	 * @return 设定文件
	 * @return List<String> 返回类型 返回格式
	 *
	 */
	public static String[] listToArr(List<String> list) {
		String[] arr = {};
		
		if(list!=null && !list.isEmpty()){
			for (int i =0;i<list.size();i++) {
				String str = list.get(i);
				if(StringUtils.isNotBlank(str)){
					arr[i] = str;
				}
			}
		}
		return arr;
	}
	
	
	/**
	 * 将以逗号","分隔的字符串转化为List
	 * 
	 * 
	 */
	public static List<String> strArrToList(String strArrWithDot){
		String[] strArr = null;
		if(StringUtils.isNotBlank(strArrWithDot)){
			strArr = strArrWithDot.split(",");
		}
		return arrToList(strArr);
	}
	
	/**
	 * 将以dot分隔的字符str串转化为List
	 * 
	 * 
	 */
	public static List<String> strArrToList(String str, String dot){
		String[] strArr = null;
		if(StringUtils.isNotBlank(str)){
			strArr = str.split(dot);
		}
		return arrToList(strArr);
	}
	
	/**
	 * 将List转化为以separator分隔的字符串（默认为逗号）
	 * separator : 分隔符
	 * 
	 */
	public static String listToStrArr(List<String> list, String separator){
		StringBuilder sb = new StringBuilder();
		if(list!=null && !list.isEmpty()){
			if(StringUtils.isBlank(separator)){
				separator = ",";
			}
			boolean flag = true;
			for (String str : list) {
				if(StringUtils.isNotBlank(str)){
					if(flag){
						sb.append(str);
						flag = false;
					}else{
						sb.append(separator).append(str);
					}
				}
			}
		}
		return sb.toString();
	}
	
	/**
	 * Set与List的转化
	 * 
	 *
	 * @return List<String>
	 */
	public static List<String> SetToList(Set<String> set){
		List<String> list = new ArrayList<String>();
		if(set!=null && !set.isEmpty()){
			list.addAll(set);
		}
		return list;
	}
	
	/**
	 * List与Set的转化
	 * 
	 * 
	 * @return List<String>
	 */
	public static Set<String> ListToSet(List<String> list){
		Set<String> set = new HashSet<String>();
		if(list!=null && !list.isEmpty()){
			set.addAll(list);
		}
		return set;
	}
	
	
	
	/**
	 * @Title: roundDoubleNum
	 * @Description: TODO(将double数值 保留cut位小数后四舍五入  )
	 * @param num
	 * @param cut
	 * @return    设定文件
	 * @return double 返回类型 返回格式
	 *
	 * 复审人：
	 */
	public static double roundDoubleNum(double num,int cut){
		String s = ".";
		for (int i = 0; i < cut; i++) {
			s+="#";
		}
		DecimalFormat df=new DecimalFormat(s);
		return Double.valueOf(df.format(num));
	}
	/**
	 * 将返回百分比
	 * <br/>支持Int与double
	 * <br/>numerator:分子；denominator：分母；cut：保留百分比小数点后几位
	 * 
	 */
	public static String formatPercentNum(Object numerator, Object denominator, int cut){
		   String res = "0.0%";
		   if(!numerator.getClass().getName().equals("java.lang.Integer") && !numerator.getClass().getName().equals("java.lang.Double")){
			   return "";
		   }
		   if(!denominator.getClass().getName().equals("java.lang.Integer") && !denominator.getClass().getName().equals("java.lang.Double")){
			   return "";
		   }
		   double num = 0;
		   double dem = 0;
		   if(numerator.getClass().getName().equals("java.lang.Integer")){
			   Integer n = (Integer) numerator;
			   num = n.doubleValue();
		   }
		   if(denominator.getClass().getName().equals("java.lang.Integer")){
			   Integer d = (Integer) denominator;
			   dem = d.doubleValue();
		   }
		   if(numerator.getClass().getName().equals("java.lang.Double")){
			   num = (Double) numerator;
		   }
		   if(denominator.getClass().getName().equals("java.lang.Double")){
			   dem = (Double) denominator;
		   }
		   if(dem != 0){
			   double percent = num / dem;
			   //获取格式化对象
			   NumberFormat nt = NumberFormat.getPercentInstance();
			   //设置百分数精确度2即保留两位小数
			   nt.setMinimumFractionDigits(cut);
			   //最后格式化并输出
			   //System.out.println("百分数：" + nt.format(percent));
			   res =  nt.format(percent);
		   }
		   return res;
	}
	
	
	 /**
	  * 把HTML内容的所有标签去掉 请使用getTextFromHtml方法
     * @param htmlStr  
     * @return
     *  删除Html标签
     */
    public static String delHTMLTag(String htmlStr) {
        Pattern p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);
        Matcher m_script = p_script.matcher(htmlStr);
        htmlStr = m_script.replaceAll(""); // 过滤script标签

        Pattern p_style = Pattern.compile(regEx_style, Pattern.CASE_INSENSITIVE);
        Matcher m_style = p_style.matcher(htmlStr);
        htmlStr = m_style.replaceAll(""); // 过滤style标签

        Pattern p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
        Matcher m_html = p_html.matcher(htmlStr);
        htmlStr = m_html.replaceAll(""); // 过滤html标签

        Pattern p_space = Pattern.compile(regEx_space, Pattern.CASE_INSENSITIVE);
        Matcher m_space = p_space.matcher(htmlStr);
        htmlStr = m_space.replaceAll(""); // 过滤空格回车标签
        return htmlStr.trim(); // 返回文本字符串
    }
    
    /**
     * 把HTML内容的所有标签去掉
     * 
     *
     */
    public static String getTextFromHtml(String htmlStr){
    	htmlStr = delHTMLTag(htmlStr);
    	htmlStr = htmlStr.replaceAll("&nbsp;", "");
    	return htmlStr;
    }
    
    
    /**
	 * 解决XXS拦截器 转义的HTML字符 反转义
	 * 
	 */
	public static String HtmlXSSreplace(String value) {
		if (!StringUtils.isEmpty(value)) {
			return value.replaceAll("& lt;", "<").replaceAll("& gt;", ">")
					.replaceAll("& #40;", "\\(").replaceAll("& #41;", "\\)")
					.replaceAll("& #39;", "'");
		} else {
			return value;
		}
	}
	
	/**
	 * 解决XXS拦截器 转义字符 反转义 (用于JSON解析时)
	 * 
	 * @param url
	 * @return
	 */
	public static String JsonXSSreplace(String value) {
		if (!StringUtils.isEmpty(value)) {
			return value.replaceAll("& lt;", "<").replaceAll("& gt;", ">")
			.replaceAll("& #40;", "\\(").replaceAll("& #41;", "\\)")
			.replaceAll("& #39;", "\\\"").replace("\"", "\\\"");
		} else {
			return value;
		}
	}
	
	/**
	 * JSON转Map
	 * 
	
	 */
	 public static Map getMap4Json(String jsonString)
	    {
	      JSONObject jsonObject = JSONObject.fromObject(jsonString);
	      Iterator keyIter = jsonObject.keys();

	      Map valueMap = new HashMap();

	      while (keyIter.hasNext())
	      {
	        String key = (String)keyIter.next();
	        Object value = jsonObject.get(key);
	        valueMap.put(key, value);
	      }

	      return valueMap;
	    }
	 
	 /**
	 * 转汉字

	 */
	 public static String URLDecoder(String bm) {
		try {
			bm = new String(bm.getBytes("ISO-8859-1"), "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return bm;
	}
	
	/**
	 * 判断字符对象是否是空 如果是空返回空串  如果不为空，返回trim
	
	 * String
	 */
	public static String null2Emp(String value){
		if(StringUtils.isBlank(value)){
			return "";
		}else{
			return StringUtils.trim(value);
		}
	}
	
	/**
	 * @Title: checkIsNum
	 * @Description: TODO(检查数字是否合法 返回double（cut位正double))
	 * @param numStr
	 * @param errorMsg
	 * @return 设定文件
	 * @return double 返回类型 返回格式

	 */
	public static double getDouble(String numStr, int cut) {
		double num = -1d;
		if (!StringUtils.isEmpty(numStr)) {
			try {
				num = roundDoubleNum(Double.parseDouble(numStr), cut);
			} catch (NumberFormatException e) {

			}
		}
		return num;
	}
	
	
	/**
	 * 将异常堆栈信息 生成为字串
	
	 * String
	 */
    public static String Exception2String(Throwable e){  
    	if(StringUtils.isNotBlank(e.getMessage())){
    		return e.getMessage();
    	}
        StringWriter sw = new StringWriter();   
        PrintWriter pw = new PrintWriter(sw, true);   
        e.printStackTrace(pw);   
        pw.flush();   
        sw.flush();   
        return sw.toString();   
    } 
	
	
	
	
}