package com.nbclass.util;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.SecureRandom;
import java.sql.PreparedStatement;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.UUID;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.codec.digest.UnixCrypt;
import org.apache.commons.lang3.StringUtils;

/**
 * 工具类
 * @author leiyun
 * @datetime 2016年3月18日 上午10:30:43
 */
public class Utility implements java.io.Serializable {

	private static final long serialVersionUID = 1L;
	
	protected static Utility instance = null;
	
	public static synchronized void setInstance(boolean clear) {
		if (clear)
			instance = null;
		else if (instance == null)
			instance = new Utility();
	}

	public static Utility getUtilityInstance() {
		if (instance == null)
			setInstance(false);
		return instance;
	}

	protected Utility() {
		instance = null;
	}
	

	/**
	 * Convert integer string array into integer array
	 * @param array
	 * @return
	 * @throws Exception
	 */
	public static int[] toIntArray(String[] array) {
		int[] result = new int[array.length];
		int count = 0;
		for (int i = 0; i < array.length; i++) {
			if (array[i] != null && !array[i].trim().equals("") && !array[i].trim().equals("undefined"))
				result[count++] = Integer.parseInt(array[i]);
		}
		return result;
	}

	/**
	 * Convert integer arraylist into integer array
	 * @param array
	 * @return
	 * @throws Exception
	 */
	public static int[] toIntArray(ArrayList<String> array) throws Exception {
		int[] result = new int[array.size()];
		int count = 0;
		for (int i = 0; i < array.size(); i++) {
			String item = array.get(i);
			if (item != null && !item.trim().equals(""))
				result[count++] = Integer.parseInt(item);
		}
		return result;
	}
	
	public static int[] toIntArray(String str){
		if(str == null || str.equals("")) return null;
		int[] result;
		if(str.indexOf(",")!=-1){
			String[] strArr = str.split(",");
			result =toIntArray(strArr);
		}else{
			result = new int[]{Integer.parseInt(str)};
		}

		return result;
	}

	public static String strArrayToString(String[] ids){
		if(ids == null || ids.length < 1) return null;
		String result = "";
		for(int i=0; i< ids.length; i++){
			result += (isEmpty(result) ? "" : ",") + ids[i];
		}
		return result;
	}
	
	public static String encodeHTML(String value) {
		if (value == null)
			return "";
		value = value.replaceAll("\"", "&#34;").replaceAll("'", "&#39;");
		value = value.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
		return value;
	}

	public static String decodeHTML(String value) {
		if (value == null)
			return "";
		value = value.replaceAll("&#34;", "\"").replaceAll("&#39;", "'");
		value = value.replaceAll("&lt;", "<").replaceAll("&gt;", ">");
		return value;
	}

	/**
	 * This function will convert the string to a unicode string. (e.g. "\u7f51")
	 * 
	 * @param value
	 * @return
	 */
	public static String toUnicodeString(String value) throws Exception {
		// Set the contant type as "UTF8".
		// <META http-equiv=content-tyhpe content="text/html; charset=UTF-8">
		if (value == null || value.equals(""))
			return value;

		String buffer = value;
		buffer = new String(buffer.getBytes("ISO8859_1"), "UTF8");
		buffer = URLEncoder.encode(buffer, "Unicode");

		StringBuffer sb = new StringBuffer();
		String[] sc = buffer.split("%FF%FE");
		// for each of unicode set
		for (int i = 0; i < sc.length; i++) {
			String si = sc[i];
			// for each of char in unicode line
			for (int j = 0; j < si.length(); j++) {
				char ch = si.charAt(j);
				if (ch == '%') {
					sb.append('\\').append('u');
					sb.append(si.substring(j + 4, j + 6).toLowerCase());
					sb.append(si.substring(j + 1, j + 3).toLowerCase());
					j += 5;
				} else {
					String ss = si.substring(j, j + 1);
					if (ss.equals("+"))
						ss = " ";
					sb.append(ss);
				}
			}
		}
		return sb.toString();
	}

	/**
	 * Create a instance from a class
	 * 
	 * @param service
	 * @return @throws
	 *         ClassNotFoundException
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 */
	public static Object instantiate(String service) throws ClassNotFoundException, InstantiationException,
			IllegalAccessException {
		ClassLoader classloader = Thread.currentThread().getContextClassLoader();
		Class<?> instance = classloader.loadClass(service);
		return instance.newInstance();
	}

	public static double getRoundUp(double d, int scale) {
		double result = d;
		BigDecimal bd = new BigDecimal(d);
		result = bd.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
		return result;
	}
	
	public static float getRoundUp(float d, int scale) {
		float result = d;
		BigDecimal bd = new BigDecimal(d);
		result = bd.setScale(scale, BigDecimal.ROUND_HALF_UP).floatValue();
		return result;
	}
	
	public static Calendar getCalendar(Date date) throws Exception {
		Calendar result = Calendar.getInstance();
		result.setTime(date);
		return result;
	}

	public static Calendar getCalendar(long milliseconds) throws Exception {
		Calendar result = Calendar.getInstance();
		result.setTimeInMillis(milliseconds);
		return result;
	}
	
	public static String getTimeStampWithMillis() {
		return getTimeStampWithMillis(Calendar.getInstance());
	}	

	public static String getTimeStampWithMillis(Calendar calendar) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		String result = sdf.format(calendar.getTime());
		return result;
	}

	/**
	 * Convert a string with format "yyyyMMddHHmmss" into Calendar object
	 * @param date
	 * @return
	 * @throws Exception
	 */
	public static Calendar getCalendar(String date) throws Exception {
		if (date == null || date.trim().equals(""))
			return null;

		for (int i = date.length(); i < 14; i++)
			date += "0";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
		Calendar result = Calendar.getInstance();

		try {
			result.setTime(sdf.parse(date));
		} catch (ParseException e) {
			result = null;
		}
		return result;
	}

	public static Calendar getCalendar(String date, String format) throws Exception {
		if (date == null || date.trim().equals(""))
			return null;

		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Calendar result = Calendar.getInstance();

		try {
			result.setTime(sdf.parse(date));
		} catch (ParseException e) {
			result = null;
		}
		return result;
	}

	public static String getDateString(Calendar date){
		return getDateString(date, "yyyyMMddHHmmss");
	}

	public static String getDateString(Calendar date, String format){
		if (date == null)	return "";
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(date.getTime());
	}
	
	public static String getHttpContent(String urlStr, String encoding) throws Exception {
		URL url = new URL(urlStr);
		InputStream is = null;
		HttpURLConnection connection = (HttpURLConnection) url.openConnection();
		try {
			if (connection.getResponseCode() != 200) {
				//return "Error: " + connection.getResponseCode() + " " + connection.getResponseMessage();
				is = connection.getErrorStream();
			} else {
				is = connection.getInputStream();
			}

			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			byte[] buffer = new byte[16384];
			int count;
			while ((count = is.read(buffer)) != -1) {
				bos.write(buffer, 0, count);
			}
			return bos.toString(encoding);
		} finally {
			connection.disconnect();
		}
	}

	public static byte[] objectToByteArray(Object obj) throws Exception {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bos);
		oos.writeObject(obj);
		oos.flush();
		oos.close();
		return bos.toByteArray();
	}

	public static byte[] InputStreamToByteArray(InputStream is) throws Exception {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		byte[] buffer = new byte[16384];
		int count;
		while ((count = is.read(buffer)) != -1) {
			bos.write(buffer, 0, count);
		}
		return bos.toByteArray();
	}
	

	public static Object byteArrayToObject(byte[] array) throws Exception {
		ByteArrayInputStream bis = new ByteArrayInputStream(array);
		ObjectInputStream ois = new ObjectInputStream(bis);
		return ois.readObject();
	}

	public static void byteArrayToFile(byte[] content, String filename) throws Exception {
		FileOutputStream out = new FileOutputStream(filename);
		out.write(content);
		out.flush();
		out.close();
	}

	public static byte[] fileToByteArray(String filename) throws Exception {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		FileInputStream fos = new FileInputStream(filename);
		byte[] buffer = new byte[10240];
		int count;
		while ((count = fos.read(buffer)) != -1)
			bos.write(buffer, 0, count);
		fos.close();
		return bos.toByteArray();
	}

	public static int[] getIntegerArray(String values) throws Exception {
		String[] slice = values.split(",");
		int[] result = new int[slice.length];
		for (int i = 0; i < slice.length; i++)
			result[i] = Integer.parseInt(slice[i]);
		return result;
	}

	public static String getFormatedDate(Calendar date) {
		return getFormatedDate(date, "yyyy-MM-dd HH:mm:ss");
	}

	public static String getFormatedDate(Calendar date, String format) {
		if (date == null)
			return "";
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(date.getTime());
	}

	public static String getFormatedTimeStamp() {
		return getFormatedTimeStamp(Calendar.getInstance());
	}
	
	public static String getFormatedTimeStamp(Calendar calendar) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
		return sdf.format(calendar.getTime());
	}
	
	public static String getTimeStamp() {
		Calendar calendar = Calendar.getInstance();
		return getTimeStamp(calendar);
	}
	
	public static String getTimeStamp(Calendar calendar) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
		String result = sdf.format(calendar.getTime());
		result = result + "000";
		return result;
	}
	

	public static String getFormatedFileSize(long value) {
		double kb = value / 1024.00;
		DecimalFormat df = new DecimalFormat("#0.00");
		return df.format(kb);
	}

	public static String getFormatedDecimal(double value) {
		return getFormatedDecimal(value, "#0.00");
	}

	public static String getFormatedDecimal(double value, int decimal) {
		String format = "#0.";
		if (decimal == 0) format = "#0";
		else {
			for (int i = 1; i <= decimal; i++) format += "0";
		}
		return getFormatedDecimal(value, format);
	}

	public static String getFormatedDecimal(double value, String format) {
		DecimalFormat df = new DecimalFormat(format);
		return df.format(value);
	}

	public static Date getMonthLastDay(int year, int month) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(year, month, 1);
		calendar.add(Calendar.DATE, -1);
		return calendar.getTime();
	}
	
	public static String getDateFormat(Date date, String format) {
		if (date == null) return "";
		SimpleDateFormat dateFormat = new SimpleDateFormat(format, Locale.US);
		return dateFormat.format(date);
	}
	
	public static java.sql.Date UtilDateToSQLDate(Date utilDate) {
		if (utilDate == null) return null;
		return new java.sql.Date(utilDate.getTime());
	}

	public static java.sql.Timestamp UtilDateToSQLTimeStamp(Date utilDate) {
		if (utilDate == null) return null;
		return new java.sql.Timestamp(utilDate.getTime());
	}

	public static java.util.Date SQLDateToUtilDate(java.sql.Date SQLDate) {
		if (SQLDate == null) return null;
		return new Date(SQLDate.getTime());
	}
	
	public static java.util.Date SQLDateToUtilDate(java.sql.Timestamp SQLDate) {
		if (SQLDate == null) return null;
		return new Date(SQLDate.getTime());
	}
	
	public static Date parseDate(String strDate, String pattern) throws Exception {
		if (strDate == null || strDate.trim().equals("")) return null;
		SimpleDateFormat format = new SimpleDateFormat(pattern);
		Date date = format.parse(strDate);
		return date;
	}
	
	public static String getSearchFormat(String pattern) {
		if (pattern == null) return "%";
		pattern = pattern.trim();	// format maybe : A, A%, %A%, A%B%, %A"B
		if (pattern.equals("")) {
			pattern = "%";
		} else if (pattern.indexOf("%") == -1) {
			pattern = "%" + pattern + "%";
		}
		return pattern;
	}
	
	public static String getLeadingZero(int intValue, int maxLength) {
		String result = String.valueOf(intValue);
		if (result.length() < maxLength) {
			while (result.length() < maxLength) {
				result = "0" + result;
			}
		}
		return result;
	}
	
	public static String getQuantityAsString(float qty) {
		DecimalFormat df = new DecimalFormat("#0.00");
		return df.format(qty);
	}
	
	public static String getQuantityAsString(double qty) {
		DecimalFormat df = new DecimalFormat("#0.00");
		return df.format(qty);
	}
	
	public static String getQuantityAsString(float amt, String pattern) {
		DecimalFormat df = new DecimalFormat(pattern);
		return df.format(amt);
	}

	public static String getQuantityAsString(double amt, String pattern) {
		DecimalFormat df = new DecimalFormat(pattern);
		return df.format(amt);
	}

	public static String getInvoiceAsString(float amt) {
		DecimalFormat df = new DecimalFormat("#,##0.00");
		return df.format(amt);
	}

	public static String getAmountAsString(float amt, String pattern) {
		DecimalFormat df = new DecimalFormat(pattern);
		return df.format(amt);
	}
	
	public static String getAmountAsString(double amt, String pattern) {
		DecimalFormat df = new DecimalFormat(pattern);
		return df.format(amt);
	}
	
	public static String getFloatFormat(float f, String pattern) {
		DecimalFormat df = new DecimalFormat(pattern);
		return df.format(f);
	}	
	
	public static String getDoubleFormat(double d, String pattern) {
		DecimalFormat df = new DecimalFormat(pattern);
		return df.format(d);
	}

	public static Date parseExcelDate(String Date) {
		Calendar calendar = Calendar.getInstance();
		long millis = (long) (Integer.parseInt(Date) - 25569)*24*60*60*1000;
		calendar.setTimeInMillis(millis);
		return calendar.getTime();
	}

    public static double mul(double d1, double d2) {
    	BigDecimal b1 = new BigDecimal(String.valueOf(d1));
    	BigDecimal b2 = new BigDecimal(String.valueOf(d2));
    	
    	return b1.multiply(b2).doubleValue();
    }
    
    public static double mul(BigDecimal b1, double d2) {
    	BigDecimal b2 = new BigDecimal(String.valueOf(d2));
    	
    	return b1.multiply(b2).doubleValue();
    }
    
    public static double add(double d1, double d2) {
    	BigDecimal b1 = new BigDecimal(String.valueOf(d1));
    	BigDecimal b2 = new BigDecimal(String.valueOf(d2));
    	
    	return b1.add(b2).doubleValue();   	
    }

	public static boolean isPositiveInteger(String inValue) {
		return isNumericValue(inValue, false, false);
	}   
	
	public static boolean isNumericValue(String inValue) {
		return isNumericValue(inValue, true, true);
	}   

	public static boolean isNumericValue(String inValue, boolean includeSymbol, boolean includeDecimal) {
		boolean result = false;
		if (inValue != null) {
			inValue = inValue.trim();
			if (!inValue.equals("")) {
				if (inValue.indexOf("=") != -1) {
					inValue = inValue.substring(inValue.indexOf("=") + 1);
				}
				inValue = inValue.trim();
				String nString = "1234567890";
				if (includeSymbol) nString += "-";
				if (includeDecimal) nString += ".";
				result = true;
				for (int i=0; i < inValue.length(); i++) {
					if (nString.indexOf(inValue.substring(i, i+1)) == -1) {
						result = false;
						break;
					}
				}
			}
		}
		return result;
	}
 
	public static String getIDAsString(ArrayList<?> idList, int idFrom, int idTo) {
		String IDs = null;
		if (idList != null && idList.size() > 0) {
			if (idFrom < 0) idFrom = 0;
			if (idTo > idList.size()) idTo = idList.size();
			int lp;
			IDs = idList.get(idFrom).toString();
			if (idList.size() > 1 && idTo > idFrom) {
				for (lp = idFrom+1; lp < idTo; lp ++) IDs += "," + idList.get(lp).toString();				
			}
		}
		return IDs;
	}

	public static String getPreparedParameterList(int fromID, int toID) {
		String result = "";
		for (int i = fromID; i <= toID; i++) {
			if (i == fromID) result += "?";
			else result += ",?";
		}
		return result;
	}
		
	public static void setPreparedParameterList(PreparedStatement stmt, int startParamIndex, ArrayList<Integer> idList, int fromID, int toID) throws Exception {
		int idx = startParamIndex;
		for (int i = fromID; i <= toID; i++) {
			stmt.setInt(idx, idList.get(i).intValue());
			idx ++;
		}		
	}
		
	public static String replaceMailAddress(String mailAddress, String oldPattern, String newPattern) {
		if (mailAddress == null || mailAddress.trim().equals("") || oldPattern == null || newPattern == null)
			return mailAddress;
		else {
			return mailAddress.trim().replaceAll(oldPattern, newPattern);
		}
	}
	
	public static String getValidMailAddress(String mailAddress, String defaultAddress) {
		if (mailAddress != null && !mailAddress.trim().equals(""))
			return mailAddress;
		else
			return defaultAddress;
	}
	
	public static String getValidString(String str) {
		if (str == null) return "";
		else return str;
	}
	
	public static String[] getMailTo(String to) {
		String[] toAC = null;
		if (to != null && to.indexOf("@") != -1) {
			if (to.indexOf(",") != -1) toAC = to.split(",");
			else if (to.indexOf(";") != -1) toAC = to.split(";");
			else if (to.indexOf(" ") != -1) toAC = to.split(" ");
			else {
				toAC = new String[1];
				toAC[0] = to;
			}
		}
		return toAC;
	}
	
	public static int getASCII(String str) {
		int result = 48;
		if (str != null && !str.trim().equals("")) {
			result = 48 + Integer.parseInt(str); 
		}
		return result; 
	}
	
	public static void getKeyAsVector(String s_key, Vector<String> v_key) {
		int idx;
		if (s_key != null && !s_key.trim().equals("")) {
			if (s_key.startsWith(".")) s_key = s_key.substring(1);
			while (s_key.length() > 0) {
				idx = s_key.indexOf(".");
				if (idx != -1) {
					v_key.addElement(s_key.substring(0, idx));
					s_key = s_key.substring(idx+1);					
				} else {
					v_key.addElement(s_key);
					s_key = "";
				}
			}
		}
	}
	
	public static String getNameFromAscII(String s_key, int startIndex, int length) {
		Vector<String> v_key = new Vector<String>();
		Utility.getKeyAsVector(s_key, v_key);
		String result = getNameFromAscII(v_key, startIndex, length);
		v_key = null;
		return result;
	}
	
	public static String getNameFromAscII(Vector<String> v_key, int startIndex, int length) {
		String result = "";
		if (length > v_key.size() - startIndex) length = v_key.size() - startIndex;
		for (int i = startIndex; i < startIndex + length; i++) {
			result += (char)Integer.parseInt(v_key.elementAt(i));
		}
		return result;
	}
	
	public static String NameToASCII(String str) {
		String result = null;
		char[] ch = str.toCharArray();
		for (int i = 0; i < ch.length; i++) {
			if (result == null) result = String.valueOf((int)ch[i]);
			else result = result + "." + String.valueOf((int)ch[i]);
		}
		return result;
	}
	
    public static void writeLog(String log) {
		try {
			System.out.println(getFormatedTimeStamp() + " : " + log);			
		} catch (Exception e) {
		}
	}      
    
	public static String intToHex(int i) {
		String result = Integer.toHexString(i).trim();
		if (result.length() == 0) result = "00";
		if (result.length() == 1) result = "0" + result;
		return result;
	}
	
	public static int HexToInt(String s) {
		return Integer.parseInt(Integer.valueOf(s, 16).toString());
	}

	public static ArrayList<String> str2List(String str){
		ArrayList<String> list = new ArrayList<>();
		if(str!=null && str.trim().length()>0){
			if(str.indexOf(",")!=-1){
				String[] arr = str.split(",");
				for (String string : arr) {
					list.add(string);
				}
			}else{
				list.add(str);
			}
		}
		return list;
	}
	
    
    public static String getDateFormat(Calendar calendar){
    	String returnValue="";
    	Date now = new Date();
		long leftTime=now.getTime()-calendar.getTimeInMillis();
		long day=leftTime/(24*60*60*1000);
		long hour=(leftTime/(60*60*1000)-day*24);
		long min=((leftTime/(60*1000))-day*24*60-hour*60);
		long s=(leftTime/1000-day*24*60*60-hour*60*60-min*60);
		 
		if(returnValue.equals("") && day>=365){
			int year = (int) (day/365);
			returnValue=year+"年前";
		}
		if(returnValue.equals("") && day>=30){
			int month = (int) (day/30);
			returnValue=month+"个月前";
		}
		if(returnValue.equals("") && day > 0)
			returnValue=day+"天前";
		if(returnValue.equals("") && hour > 0 )
			returnValue=hour+"小时前";
		if(returnValue.equals("") && min > 0 )
			returnValue=min+"分前";
		if(returnValue.equals("") && s > 0)
			returnValue=s+"秒前";
		if(returnValue.equals(""))
			returnValue="0秒前";
		
		return returnValue;
    }
    
    public static String getUUID(){
    	return java.util.UUID.randomUUID().toString();
    }
	
    /**
     * 格式化日期  eg. 2014年07月10日  12:29 星期四
     * @param date
     * @return
     */
    public static String getDateCN(Date date){
    	SimpleDateFormat dateFm = new SimpleDateFormat("yyyy年MM月dd日  HH:mm  EEEE");
    	return dateFm.format(date);
    	  
    }
    
    /**
     * 获取文件的后缀名
     * @param filename
     * @return
     */
    public static String getFileSuffix(String filename){
    	String suffix="";
    	if(filename!=null && filename.indexOf(".")!=-1)suffix=filename.substring(filename.lastIndexOf("."));
    	return suffix;
	}
    
    public static String getFileSuffix(File file){
    	String fileName=file.getName();
    	return getFileSuffix(fileName);
    }
    
    /**
     * 获取访问者IP
     * 在一般情况下使用Request.getRemoteAddr()即可，但是经过nginx等反向代理软件后，这个方法会失效。
     * 本方法先从Header中获取X-Real-IP，如果不存在再从X-Forwarded-For获得第一个IP(用,分割)，
     * 如果还不存在则调用Request.getRemoteAddr()。
     * @param request
     * @return
     */
    public static String getClientIPAddr(HttpServletRequest request) {
    	String ip = request.getHeader("x-forwarded-for");
    	if (!StringUtils.isBlank(ip) && !"unknown".equalsIgnoreCase(ip)) {
            // 多次反向代理后会有多个IP值，第一个为真实IP。
            int index = ip.indexOf(',');
            if (index != -1) {
            	ip = ip.substring(0, index);
            }
        }
        if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("PRoxy-Client-IP");  
        }
        if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");  
        }
        if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
        	ip = request.getHeader("X-Real-IP");
        }
        if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();  
        }
        return ip;
    }
    
	public static String listToString(List<?> stringList){
		if (stringList==null) {
            return null;
        }
        StringBuilder result=new StringBuilder();
        boolean flag=false;
        for (Object string : stringList) {
            if (flag) {
                result.append(",");
            }else {
                flag=true;
            }
            result.append(String.valueOf(string));
        }
        return result.toString();
	}
	
	
	public static boolean strIsEqual(String str1, String str2){
		if(StringUtils.isBlank(str1) || StringUtils.isBlank(str2))return false;
		if(str1.equals(str2) || str1.trim().equals(str2.trim()))return true;
		else return false;
	}

	/**
	 * 判断是否是整数
	 * @param str
	 * @return
	 */
	public static boolean isNumber(String str){
		if(StringUtils.isEmpty(str))return false;
		try {
			Long.parseLong(str);
			return true;
		} catch (Exception e) {
			return false;
		}
	}
	
	/**
	 * 判断是否是浮点数
	 * @param str
	 * @return
	 */
	public static boolean isDouble(String str){
		if(StringUtils.isEmpty(str))return false;
		try {
			Double.parseDouble(str);
			return true;
		} catch (Exception e) {
			return false;
		}
	}	
	
	/**
	 * 密码加密方法
	 * @param pwd
	 * @return
	 */
	public static String encryptPwd(String pwd){
		if(StringUtils.isEmpty(pwd))return null;
		else return UnixCrypt.crypt(pwd, DigestUtils.sha256Hex(pwd));
	}
	
	/**
	 * 优惠码的生成, 默认6为长度
	 * @return
	 */
	public static String getCode() {
		return getCode(6);
	}
	
	/**
	 * 优惠码的生成
	 * @return
	 */
	public static String getCode(int length) {
		char[] chs = { 'a', 'b', 'c', '1', '2', '3', '4', '5', 'd', 'e', 'f',
				'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
				's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '6', '7', '8', '9' };
		SecureRandom random = new SecureRandom();
		final char[] value = new char[length];
		for (int i = 0; i < length; i++) {
			value[i] = chs[random.nextInt(chs.length)];
		}
		final String code = new String(value);
		return code;
	}
	
	/**
	 * 通过正则验证手机号码是否正确
	 * @param str
	 * @return
	 */
	public static boolean isMobile(String str) {
        boolean b = false;
        Pattern p=Pattern.compile("^1(3|4|5|7|8)\\d{9}$");
        Matcher m = p.matcher(str);
        b = m.matches();
        return b;
	}
	
	/**
	 * 使用urlencode对链接进行编码
	 * @param url
	 * @return
	 */
	public static String UrlEncode(String url){
		if(url == null || url.trim().equals(""))return null;
		try {
			return URLEncoder.encode(url, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 使用URLDecoder对链接进行解码
	 * @param url
	 * @return
	 */
	public static String UrlDecode(String url){
		if(url == null || url.trim().equals(""))return null;
		try {
			return URLDecoder.decode(url, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
			return null;
		}
	}

	public static boolean isEmpty(String str){
		return (str == null || "".equals(str.trim()));
	}
	
	public static boolean isNotEmpty(String str){
		return (str != null && str.trim().length() > 0);
	}

	/**
	 * 判断文件是否是图片
	 * @param file
	 * @return
	 */
	public static boolean isImage(File file){
		if(file == null)return false;
		boolean flag = false;
		try {
			InputStream inputStream = new FileInputStream(file);
			flag = isImage(inputStream);
			inputStream.close();
		} catch (Exception e) {
		}
		return flag;
	}
	
	/**
	 * 判断输入流是否是图片
	 * @param inputStream
	 * @return
	 */
	public static boolean isImage(InputStream inputStream){
		boolean flag = false;
		try {
			BufferedImage Image=ImageIO.read(inputStream);
			if(null == Image) {
				return flag;
			}
			Image.flush();
			flag = true;
		} catch (Exception e){
		}
		return flag;
	}
	
	/**
	 * 通过文件路径获取文件的ContentType
	 *  JDK1.7以上支持
	 * @param filePath
	 * @return ContentType
	 */
	public static String getFileContentType(String filePath){
		String contentType = null;
		try {
			contentType = Files.probeContentType(Paths.get(filePath));
		} catch (IOException e) {
			e.printStackTrace();
		}
		return contentType;
	}
    
	public static String getReqIpAddr(HttpServletRequest request) {
		String ip = null;
		try {
			ip = request.getHeader("x-forwarded-for");
			if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
				ip = request.getHeader("Proxy-Client-IP");
			}
			if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
				ip = request.getHeader("WL-Proxy-Client-IP");
			}
			if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
				ip = request.getRemoteAddr();
			}
			if(ip == null){
				ip = "未知IP";
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
        
        return ip;
    }
	
	/**
	 * 获取http访问路径，包括ContextPath
	 * @param request
	 * @return
	 */
	public static String getDomainPath(HttpServletRequest request){
		String strport = "";
		int port = request.getServerPort();
		if(port != 80){
			strport = ":"+port;
		}
		String domainPath = request.getScheme()+"://"+request.getServerName()+strport+request.getContextPath();
		return domainPath;
	}
	
    /**
     * 生成微信支付需要的nonce_str参数
     * @return
     */
    public static String getNonceStr(){
    	return UUID.randomUUID().toString().replace("-", "");  
    }
    
    /**
	 * 生成[min,max]区间的随机小数 (保留2位小数)
	 * @param min
	 * @param max
	 * @return
	 */
	public static double getRandom(double min, double max){
		return getRandom(min, max, 2);
	}
	
	/**
	 * 生成[min,max]区间的随机小数
	 * @param min
	 * @param max
	 * @param scale 精度位数(保留的小数位数)
	 * @return
	 */
	public static double getRandom(double min, double max, int scale){
		Random r = new Random();
		double result = r.nextDouble() * (max-min) + min;
		result = round(result, scale); // 精度位数(保留的小数位数)
		return result;
	}
	
	private static double round(double value, int scale) {
		return round(value, scale, BigDecimal.ROUND_HALF_UP);
	}
	
	/**  
    * 对double数据进行取精度.  
    * @param value  double数据.  
    * @param scale  精度位数(保留的小数位数).  
    * @param roundingMode  精度取值方式.  
    * @return 精度计算后的数据.  
	*/  
	private static double round(double value, int scale, int roundingMode) {
       BigDecimal bd = new BigDecimal(value);
       bd = bd.setScale(scale, roundingMode);
       double d = bd.doubleValue();
       bd = null;
       return d;
	}
    
	/**
	 * double保留2位小数
	 * @param value
	 * @return
	 */
	public static double getDouble2(double value) {
	   BigDecimal bd = new BigDecimal(value);
	   bd = bd.setScale(2, BigDecimal.ROUND_HALF_UP);
	   double d = bd.doubleValue();
	   bd = null;
	   return d;
	}
	
	/**
     * 向URL中添加参数(有则修改，无则添加)
     * @param url
     * @param ParamName
     * @param ParamValue
     * @return
     */
	public static String addParamValue(String url, String ParamName, String ParamValue) {
        if(StringUtils.isNotBlank(url) && StringUtils.isNotBlank(ParamName) && StringUtils.isNotBlank(ParamValue)) {
            if(url.contains(ParamName+"=")){
            	url = replaceParamValue(url, ParamName, ParamValue);
            }else{
            	if(url.contains("?") || url.contains("\\?")){
                	url += "&"+ParamName+"=" + ParamValue;
                }else{
                	url += "?"+ParamName+"=" + ParamValue;
                }
            }
        }
        return url;
    }
    
    /**
     * 替换URL参数的值
     * @param url
     * @param ParamName
     * @param ParamValue
     * @return
     */
	public static String replaceParamValue(String url, String ParamName, String ParamValue) {
		if(StringUtils.isNotBlank(url) && StringUtils.isNotBlank(ParamName) && StringUtils.isNotBlank(ParamValue)) {
            url = url.replaceAll("(\\?" + ParamName +"=[^&]*)", "?"+ParamName + "=" + ParamValue);
            url = url.replaceAll("(\\&" + ParamName +"=[^&]*)", "&"+ParamName + "=" + ParamValue);
        }
        return url;
    }
	
	/**
	 * 删除URL中的参数
	 * @param url
	 * @param ParamName
	 * @return
	 */
	public static String removeParamValue(String url, String ParamName) {
        if(StringUtils.isNotBlank(url) && StringUtils.isNotBlank(ParamName)) {
        	while(url.contains("?"+ParamName+"=") || url.contains("%3f"+ParamName+"%3d") || url.contains("%3F"+ParamName+"%3D")
        		|| url.contains("&"+ParamName+"=") || url.contains("%26"+ParamName+"%3d") || url.contains("%26"+ParamName+"%3D")){
        		url = url.replaceAll("(\\?" + ParamName +"=[^&]*)", "");
            	url = url.replaceAll("(%3f" + ParamName +"%3d[^&]*)", "");
                url = url.replaceAll("(%3F" + ParamName +"%3D[^&]*)", "");
                
            	url = url.replaceAll("(\\&" + ParamName +"=[^&]*)", "");
            	url = url.replaceAll("(%26" + ParamName +"%3d[^&]*)", "");
                url = url.replaceAll("(%26" + ParamName +"%3D[^&]*)", "");
            }
        }
        return url;
    }


	/**
	 * 获取当天日期
	 * @return
	 */
	public static int getDateNum() {
		return getDateNum(new Date());
	}
	// 获取指定时间日期
	public static int getDateNum(Date date) {
		String dateStr = getDateFormat(date, "yyyyMMdd");
		int dateNum = Integer.parseInt(dateStr);
		return dateNum;
	}

	public static String getRandomCode() {
		return getRandomCode(5);
	}

	public static String getRandomCode(int length) {
		char[] chs = { 'a', 'b', 'c', '1', '2', '3', 'd', 'e', 'f',
				'A', 'B', 'C', 'D', 'E', 'F',
				'4', '5',
				'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
				'6', '8',
				'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
				's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '6', '7', '8', '9',
				'2', '5', '9',
				'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };

		SecureRandom random = new SecureRandom();
		char[] value = new char[length];
		for (int i = 0; i < length; i++) {
			value[i] = chs[random.nextInt(chs.length)];
		}
		String code = new String(value);
		return code;
	}

    public static void main(String[] args) {
		System.out.println(getDouble2(2.31468d));
	}
}