java 打开系统文件夹路径 java如何打开文件夹

1、Runtime.getRuntime().exec("explorer D:\\Java");

2、java.awt.Desktop.getDesktop().open(new File("D:\\Java"));

4、java.awt.Desktop.getDesktop().browse(...)

3、    try {  
                String[] cmd = new String[5];  
                cmd[0] = "cmd";  
                cmd[1] = "/c";  
                cmd[2] = "start";  
                cmd[3] = " ";  
                cmd[4] = FILE_PATH;  
                Runtime.getRuntime().exec(cmd);  
            } catch (IOException e) {  
                e.printStackTrace();  
            }

4、    /*** 
         *  
         * @param folder 
         *            : directory 
         */  
        public static void open_directory(String folder) {  
            File file = new File(folder);  
            if (!file.exists()) {  
                return;  
            }  
            Runtime runtime = null;  
            try {  
                runtime = Runtime.getRuntime();  
                if (!SystemUtil.isWindows) {  
                    // System.out.println("is linux");  
                    runtime.exec("nautilus " + folder);  
                } else {  
                    runtime.exec("cmd /c start explorer " + folder);  
                }  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            } finally {  
                if (null != runtime) {  
                    runtime.runFinalization();  
                }  
            }  
        }

5、    /*** 
         *  
         * @param filePath 
         *            : only regular file 
         */  
        public static void open_file(String filePath) {  
            File file = new File(filePath);  
            if (!file.exists()) {  
                return;  
            }  
            Runtime runtime = null;  
            try {  
                runtime = Runtime.getRuntime();  
                if (!SystemUtil.isWindows) {  
                    // System.out.println("is linux");  
                    runtime.exec("nautilus " + filePath);  
                } else {  
                    runtime.exec("cmd /c start explorer /select,/e, " + filePath);  
                }  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            } finally {  
                if (null != runtime) {  
                    runtime.runFinalization();  
                }  
            }  
        }

其他工具类

package com.common.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigInteger;
import java.net.URLEncoder;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.crypto.Cipher;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.ServletContext;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import org.apache.commons.lang.StringUtils;

import com.io.hw.exception.MyException;
import com.io.hw.file.util.FileUtils;
import com.string.widget.util.ValueWidget;
import com.time.util.TimeHWUtil;

public class SystemUtil {
	public static final String OSNAME = System.getProperty("os.name");
	public static final String OSARCH = System.getProperty("os.arch");
	public static final String SEPARATOR = System.getProperty("file.separator");
	public static final String USER_DIR = System.getProperty("user.dir");
	public static final String CURR_ENCODING = System
			.getProperty("file.encoding");
	public static final String LINE_SEPARATOR = System
			.getProperty("line.separator");
	public static final String CRLF = LINE_SEPARATOR; // Carriage Return/Line
	// Feed
	public static final String CRLF_LINUX = "\n";
	public static final String CHARSET_UTF = "UTF-8";
	public static final String CHARSET_GBK = "GBK";
	public static final String CHARSET_GB2312 = "GB2312";
	public static final String CHARSET_GB18030 = "GB18030";
	public static final String CHARSET_UNICODE = "UNICODE";
	public static final String CHARSET_ISO88591 = "ISO-8859-1";

	public static boolean isWindows = false;
	public static boolean isHP_UX = false;
	public static boolean isSolaris = false;
	public static boolean isOS32bit = true;
	public static final int BUFF_SIZE = 4096;
	public static final String KEY_ALGORITHM_RSA = "RSA";
	public final static String KEY_ALGORITHM_DES = "DES";
	public static final String KEY_ALGORITHM_SHA1withRSA = "SHA1withRSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
	public static final String KEY_SHA = "SHA";
	public static final String KEY_SHA1 = "SHA-1";
	public static final String KEY_MD5 = "MD5";
	public static final String KEY_HMAC_SHA256 = "HMACSHA256";
	public static final String KEY_HMAC_SHA1 = "HmacSHA1";
	public static final String CERTIFICATEFACTORY_X509 = "X.509";
	public static final char[] HEXCHAR = { '0', '1', '2', '3', '4', '5', '6',
			'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
	public static BigInteger bigInt1 = BigInteger.valueOf(1l);
	public static final String CONTENTTYPE_HTML = "text/html";
	public static final String CONTENTTYPE_JSON = "application/json";
	public static final String CONTENTTYPE_X_WWW_FORM_URLENCODED = "application/x-www-form-urlencoded";

	public static final String CONTENTTYPE_OCTET_STREAM = "application/octet-stream";

	public static final String PROCOTOL_HTTP = "http";
	public static final String PROCOTOL_HTTPS = "https";
	public static final String COLON = ":";
    /**
     * 字符串空格
     */
    public static final String BLANK = " ";
    public static final String ENGLISH_PERIOD = ".";
	public static final String DIVIDING_LINE = "---------------------------------------";

	public static final int NEGATIVE_ONE = -1;
	public static final String EMPTY = "";
	static {
		if (SystemUtil.OSNAME.toLowerCase().contains("window")) {
			isWindows = true;
		}
		if (SystemUtil.OSNAME.toLowerCase().contains("hp-ux")) {
			isHP_UX = true;
		}
		if (SystemUtil.OSNAME.toLowerCase().contains("Solaris")) {
			isSolaris = true;
		}
		if (SystemUtil.OSARCH.contains("64")) {
			isOS32bit = false;
		}
	}

	private SystemUtil() {
		throw new Error("Don't let anyone instantiate this class.");
	}

	public static void copyFile(String resourceFileName, String targetFileName)
			throws IOException {
		File resourceFile = new File(resourceFileName);
		File targetFile = new File(targetFileName);
		if (!resourceFile.exists()) {
			System.out.println("[copyFile ]: resource file has not been found:"
					+ resourceFileName);
		}
		if (!resourceFile.isFile()) {
			System.out.println("[copyFile ]: directory can not be copyed:"
					+ resourceFileName);
		}

		if (targetFile.isDirectory()) {
			targetFile = new File(targetFile, resourceFile.getName());
		}

		FileInputStream resource = null;
		FileOutputStream target = null;
		try {
			resource = new FileInputStream(resourceFile);
			target = new FileOutputStream(targetFile);
			copyFile(resourceFile, targetFile);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (resource != null) {
				resource.close();
			}
			if (target != null) {
				target.close();
			}
		}
	}

	/**
	 * 
	 * @param srcFile
	 *            :must be regular file,can not be folder;
	 * @param targetFile
	 *            :must be regular file,can not be folder;
	 * @throws IOException
	 */
	public static void copyFile(File srcFile, File targetFile)
			throws IOException {
		FileInputStream in = new FileInputStream(srcFile);

		FileOutputStream out = new FileOutputStream(targetFile);
		copyFile(in, out);

	}

	public static void copyFile(InputStream in, FileOutputStream target)
			throws IOException {
		// File targetFile = new File(targetFileName);
		// FileOutputStream target = null;
		// if (targetFile.isDirectory())
		// {
		// targetFile = new File(targetFile, simpleName);
		// }
		try {
			// target = new FileOutputStream(targetFile);
			byte[] buffer = new byte[BUFF_SIZE];
			int byteNum;

			while ((byteNum = in.read(buffer)) != NEGATIVE_ONE) {
				target.write(buffer, 0, byteNum);

			}
			System.out.println("[SystemUtil:copyFile]:file copy successfully!");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (in != null) {
				in.close();
				in = null;
			}
			if (target != null) {
				target.close();
				target = null;
			}
		}
	}

	/**
	 * 
	 * @param fullpath
	 *            :/a/b/c/d
	 * @return /a/b/c/
	 */
	public static String getParentDir(String fullpath) {
		// String parentDir = null;
		if (ValueWidget.isNullOrEmpty(fullpath)) {
			System.out.println("The first argument can not be null");
			return null;
		}

		// if (fullpath.contains("/")) {
		// int index=fullpath.lastIndexOf("/") ;
		// parentDir = fullpath.substring(0, index+ 1);
		// }
		return new File(fullpath).getParent();
	}

	/**
	 * 
	 * @param fullpath
	 *            :/a/b/c/d
	 * @return d
	 */
	public static String getFileSimpleName(String fullpath) {
		// String parentDir = null;
		if (null == fullpath) {
			System.out.println("The first argument can not be null");
			return null;
		}
		// if (fullpath.contains("/")) {
		// parentDir = fullpath.substring(fullpath.lastIndexOf("/") + 1);
		// }
		return new File(fullpath).getName();
	}

	// public static void main(String[] args) throws IOException
	// {
	// copyFile("/home/whuang2/study/linux/study/c/main.exe", "/home/whuang2");
	// }
	public static String convertUTF2ISO(String oldName) {
		if (oldName == null) {
			return oldName;
		}
		try {
			return new String(oldName.getBytes(CHARSET_UTF), CHARSET_ISO88591);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static String convertGBK2ISO(String input) {
		if (input == null) {
			return input;
		}
		try {
			return new String(input.getBytes(CHARSET_GBK), CHARSET_ISO88591);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	/***
	 * convert GBK to UTF-8
	 * 
	 * @param input
	 * @return
	 * @throws UnsupportedEncodingException
	 */
	public static byte[] convertGBK2UTF(byte[] input)
			throws UnsupportedEncodingException {
		return new String(input, SystemUtil.CHARSET_GBK)
				.getBytes(SystemUtil.CHARSET_UTF);
	}

	public static byte[] convertFromeGBK(byte[] input, String toCharset)
			throws UnsupportedEncodingException {
		return new String(input, SystemUtil.CHARSET_GBK).getBytes(toCharset);
	}

	/***
	 * convert utf-8 to gbk
	 * 
	 * @param input
	 * @return
	 */
	public static String convertUTF2GBK(String input) {
		if (input == null) {
			return input;
		}
		try {
			return new String(input.getBytes(CHARSET_UTF), CHARSET_GBK);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static String convertISO2UTF(String oldName) {
		if (oldName == null) {
			return oldName;
		}
		try {
			return new String(oldName.getBytes(CHARSET_ISO88591), CHARSET_UTF);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static String convertISO2GBK(String input) {
		if (input == null) {
			return input;
		}
		try {
			return new String(input.getBytes(CHARSET_ISO88591), CHARSET_GBK);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static void printFilesSimpleName(File[] files) {
		for (File file : files) {
			System.out.println(file.getName());
		}
	}

	public static void printFilesFilePath(File[] files) {
		for (File file : files) {
			System.out.println(file.getAbsolutePath());
		}
	}

	/***
	 * 
	 * @param srcfile
	 *            : source file
	 * @param targfile
	 *            : target file
	 * @param inputCharset
	 *            : from charset
	 * @param outputCharset
	 *            : to charset
	 */
	public static void convertEncoding(File srcfile, File targfile,
			String inputCharset, String outputCharset) {
		FileInputStream fin = null;
		FileOutputStream fout = null;
		char[] cbuf = new char[BUFF_SIZE];
		int size_char;
		try {
			fin = new FileInputStream(srcfile);
			fout = new FileOutputStream(targfile);
			InputStreamReader isr = null;
			OutputStreamWriter osw = null;
			try {
				isr = new InputStreamReader(fin, inputCharset);
				osw = new OutputStreamWriter(fout, outputCharset);
				while ((size_char = isr.read(cbuf)) != NEGATIVE_ONE) {
					osw.write(cbuf, 0, size_char);
				}
				//
			} catch (UnsupportedEncodingException e1) {
				e1.printStackTrace();
			} catch (IOException e1) {
				e1.printStackTrace();
			} finally {
				try {
					isr.close();
					osw.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}

			}

		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		} finally {
			try {
				if (fin != null) {
					fin.close();
				}
				if (fout != null) {
					fout.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}
	}

	/**
	 * delete the same one
	 * 
	 * @param list
	 * @return
	 */
	public static List<String> guolv(List<String> list) {
		List<String> newlist = new ArrayList<String>();
		if (list != null && list.size() > 0) {
			newlist.add(list.get(0));
			for (int i = 1; i < list.size(); i++) {
				if (!newlist.contains(list.get(i))) {
					newlist.add(list.get(i));
				}
			}
		}
		return newlist;
	}

	/***
	 * delete CRLF; delete empty line ;delete blank lines
	 * 
	 * @param input
	 * @return
	 */
	private static String deleteCRLFOnce(String input) {
		if (ValueWidget.isHasValue(input)) {
			return input.replaceAll("((\r\n)|\n)[\\s\t ]*(\\1)+", "$1")
					.replaceAll("^((\r\n)|\n)", "");
		} else {
			return null;
		}
	}

	/***
	 * Delete all spaces
	 * 
	 * @param input
	 * @return
	 */
	public static String deleteAllCRLF(String input) {
		return input.replaceAll("((\r\n)|\n)[\\s\t ]*", "").replaceAll(
				"^((\r\n)|\n)", "");
	}

	/**
	 * delete CRLF; delete empty line ;delete blank lines
	 * 
	 * @param input
	 * @return
	 */
	public static String deleteCRLF(String input) {
		input = SystemUtil.deleteCRLFOnce(input);
		return SystemUtil.deleteCRLFOnce(input);
	}

	/***
	 * Use uniqueness of collection
	 * 
	 * @param list
	 * @return
	 */
	public static List<String> guolv2(List<String> list) {
		Set<String> set = new HashSet<String>(list);
		return new ArrayList<String>(set);
	}

	/**
	 * delete the same one
	 * 
	 * @param list
	 * @return
	 */
	public static List<Integer> guolvInteger(List<Integer> list) {
		List<Integer> newlist = new ArrayList<Integer>();
		if (list != null && list.size() > 0) {
			newlist.add(list.get(0));
			for (int i = 1; i < list.size(); i++) {
				if (!newlist.contains(list.get(i))) {
					newlist.add(list.get(i));
				}
			}
		}
		return newlist;
	}

	public static List<Integer> guolvInteger2(List<Integer> list) {
		Set<Integer> set = new HashSet<Integer>(list);
		return new ArrayList<Integer>(set);
	}

	/**
	 * 字节数大于1，则返回true
	 * 
	 * @param c
	 * @return
	 */
	public static boolean isChinese(char c) {
		return String.valueOf(c).getBytes().length > 1;
	}

	/**
	 * 判断str 中的所有字符是否全部是中文字符（包括中文的标点符号）
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isAllChinese(String str) {
		char[] cs = null;
		if (str.length() == 1) {
			cs = new char[1];
			cs[0] = str.charAt(0);
		} else {
			cs = str.toCharArray();
		}
		for (int i = 0; i < cs.length; i++) {
			char c = cs[i];
			if (!isChinese(c)) {
				return false;
			}
		}
		return true;
	}

	public static boolean isHasChinses(String str) {
		String encodeName = "UTF-8";
		for (int i = 0; i < str.length(); i++) {
			try {
				String singleStr = str.substring(i, i + 1);
				int leng = getEncodeLength(singleStr, encodeName);
				// System.out.println(singleStr + "\t" + leng);
				if (leng == 9)// 表示是中文字符
				{
					// System.out.println("有中文");
					return true;
				}
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			} catch (MyException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return false;
	}

	public static boolean isHasChinses2(String str) {
		String encodeName = "UTF-8";
		char[] chars = str.toCharArray();
		for (int i = 0; i < chars.length; i++) {
			try {
				char c = chars[i];
				int leng = getEncodeLength(c, encodeName);
				// System.out.println(singleStr + "\t" + leng);
				if (leng == 9)// 表示是中文字符
				{
					// System.out.println("有中文");
					return true;
				}
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			} catch (MyException e) {
				e.printStackTrace();
			}
		}
		return false;
	}

	public static int getEncodeLength(String str, String encodeName)
			throws Exception, UnsupportedEncodingException {// 返回值为9 的话，则说明有中文。
		if (str.length() != 1) {
			throw new Exception("超过一个字符");
		}
		String encod = URLEncoder.encode(str, "UTF-8");
		return encod.length();
	}

	public static int getEncodeLength(char c, String encodeName)
			throws MyException, UnsupportedEncodingException {// 返回值为9
		// 的话，则说明有中文。
		String encod = URLEncoder.encode(String.valueOf(c), "UTF-8");
		return encod.length();
	}

	/**
	 * 删除input字符串中的html格式
	 * 
	 * @param input
	 * @param length
	 *            显示的字符的个数
	 * @return
	 */
	public static String splitAndFilterString(String input, int length) {
		if (input == null || input.trim().equals("")) {
			return "";
		}
		// 去掉所有html元素,
		String str = input.replaceAll("\\&[a-zA-Z]{1,10};", "").replaceAll(
				"<[^>]*>", "");
		str = str.replaceAll("[(/>)<]", "");
		int len = str.length();
		if (len <= length) {
			return str;
		} else {
			str = str.substring(0, length);
			str += "......";
		}
		return str;
	}

	/**
	 * 返回纯文本,去掉html的所有标签,并且去掉空行
	 * 
	 * @param input
	 * @return
	 */
	public static String splitAndFilterString(String input) {
		if (input == null || input.trim().equals("")) {
			return "";
		}
		// 去掉所有html元素,
		String str = input.replaceAll("\\&[a-zA-Z]{1,10};", "").replaceAll(
				"<[^>]*>", "");
		str = str.replaceAll("[(/>)<]", "");
		return SystemUtil.deleteCRLF(str);
	}

	public static boolean contains(List<Object> list, Object value) {
		if (list == null || list.size() == 0) {
			return false;
		} else {
			for (int i = 0; i < list.size(); i++) {
				String valueStr;
				if (value instanceof File) {
					valueStr = ((File) value).getName();
				} else {
					valueStr = value.toString();
				}
				Object obj = list.get(i);
				if (obj instanceof File) {
					if (list.contains(valueStr)
							|| ((File) obj).getName().toString()
									.equals(valueStr)) {
						return true;
					}
				} else {
					if (list.contains(valueStr)
							|| list.get(i).toString().equals(valueStr)) {
						return true;
					}
				}
			}
		}
		return false;
	}

	/**
	 * minus Set
	 * 
	 * @param oldList
	 * @param list
	 * @return
	 */
	public static List<Object> getMinusSet(List oldList, List list) {
		List selectedList = null;
		if (oldList != null) {
			selectedList = new ArrayList<Object>();
			int leng = oldList.size();
			if (leng != 0) {
				for (int i = 0; i < leng; i++) {
					Object obj = oldList.get(i);
					if (!contains(list, obj)) {
						selectedList.add(obj);
					}
				}
			}
		}
		return selectedList;
	}

	public static List<File> getMinusSetFile(List oldList, List list) {
		List selectedList = null;
		if (oldList != null) {
			selectedList = new ArrayList<File>();
			int leng = oldList.size();
			if (leng != 0) {
				for (int i = 0; i < leng; i++) {
					Object obj = oldList.get(i);
					if (!contains(list, obj)) {
						selectedList.add(obj);
					}
				}
			}
		}
		return selectedList;
	}

	public static List<String> getMinusSetStr(List oldList, List list) {
		List selectedList = null;
		if (oldList != null) {
			selectedList = new ArrayList<Object>();
			int leng = oldList.size();
			if (leng != 0) {
				for (int i = 0; i < leng; i++) {
					Object obj = oldList.get(i);
					if (!contains(list, obj)) {
						selectedList.add(obj);
					}
				}
			}
		}
		return selectedList;
	}

	/**
	 * Get MD5 of one file:hex string,test OK!
	 * 
	 * @param file
	 * @return
	 */
	public static String getFileMD5(File file) {
		if (!file.exists() || !file.isFile()) {
			return null;
		}
		MessageDigest digest = null;
		FileInputStream in = null;
		byte buffer[] = new byte[1024];
		int len;
		try {
			digest = MessageDigest.getInstance("MD5");
			in = new FileInputStream(file);
			while ((len = in.read(buffer, 0, 1024)) != NEGATIVE_ONE) {
				digest.update(buffer, 0, len);
			}
			in.close();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		BigInteger bigInt = new BigInteger(1, digest.digest());
		return bigInt.toString(16);
	}

	/***
	 * Get MD5 of one file！test ok!
	 * 
	 * @param filepath
	 * @return
	 */
	public static String getFileMD5(String filepath) {
		File file = new File(filepath);
		return getFileMD5(file);
	}

	/**
	 * MD5 encrypt,test ok
	 * 
	 * @param data
	 * @return byte[]
	 * @throws Exception
	 */
	public static byte[] encryptMD5(byte[] data) throws Exception {

		MessageDigest md5 = MessageDigest.getInstance(SystemUtil.KEY_MD5);
		md5.update(data);
		return md5.digest();
	}

	public static byte[] encryptMD5(String data) throws Exception {
		return encryptMD5(data.getBytes(SystemUtil.CHARSET_ISO88591));
	}

	/***
	 * compare two file by Md5
	 * 
	 * @param file1
	 * @param file2
	 * @return
	 */
	public static boolean isSameMd5(File file1, File file2) {
		String md5_1 = SystemUtil.getFileMD5(file1);
		String md5_2 = SystemUtil.getFileMD5(file2);
		return md5_1.equals(md5_2);
	}

	/***
	 * compare two file by Md5
	 * 
	 * @param filepath1
	 * @param filepath2
	 * @return
	 */
	public static boolean isSameMd5(String filepath1, String filepath2) {
		File file1 = new File(filepath1);
		File file2 = new File(filepath2);
		return isSameMd5(file1, file2);
	}

	/***
	 * the times target occur in <code>int[] ints</code>
	 * 
	 * @param ints
	 * @param target
	 * @return
	 */
	public static int count(int[] ints, int target) {
		int count = 0;
		for (int i = 0; i < ints.length; i++) {
			if (ints[i] == target) {
				count++;
			}
		}
		return count;
	}

	/***
	 * Ignore Case
	 * 
	 * @param strs
	 * @param target
	 * @return
	 */
	public static int count(String[] strs, String target) {
		int count = 0;
		for (int i = 0; i < strs.length; i++) {
			if (strs[i].equalsIgnoreCase(target)) {
				count++;
			}
		}
		return count;
	}

	/***
	 * Ignore Case
	 * 
	 * @param list
	 * @param target
	 * @return
	 */
	public static int count(List<String> list, String target) {
		int count = 0;
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i).equalsIgnoreCase(target)) {
				count++;
			}
		}
		return count;
	}

	// public static void printSet(Set<Integer>set ){
	// for(Iterator<Integer> it=set.iterator();it.hasNext();){
	// Integer age=it.next();
	// System.out.println(age);
	// }
	// }

	/***
	 * 
	 * @param list
	 */
	public static void printList(List<?> list, boolean isNewline,
			String delimiter) {
		for (int i = 0; i < list.size(); i++) {
			Object obj = list.get(i);
			if (isNewline) {
				System.out.println(obj);
			} else {
				System.out.print(obj + delimiter);
			}
		}
	}

	public static void printList(List<?> list, String delimiter) {
		printList(list, true, delimiter);
	}

	public static void printStrList(List<String> list) {
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}

	public static void printSet(Set<Object> set) {
		for (Iterator<Object> it = set.iterator(); it.hasNext();) {
			Object age = it.next();
			System.out.println(age);
		}
	}

	public static <T extends Serializable> T clone2(T obj) {
		T clonedObj = null;
		try {
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(obj);
			oos.close();
			ByteArrayInputStream bais = new ByteArrayInputStream(
					baos.toByteArray());
			ObjectInputStream ois = new ObjectInputStream(bais);
			clonedObj = (T) ois.readObject();
			ois.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return clonedObj;
	}

	/***
	 * convert byte array to public key algorithm : RSA
	 * 
	 * @param keyBytes
	 *            byte[]
	 * @return RSAPublicKey
	 * @throws Exception
	 */
	public static PublicKey convert2PublicKey(byte[] keyBytes) throws Exception {
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory
				.getInstance(SystemUtil.KEY_ALGORITHM_RSA);// RSA
		PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
		return publicKey;
	}

	/***
	 * 
	 * @param keyHexStr
	 *            : hex(16) string
	 * @return PublicKey
	 * @throws Exception
	 */
	public static PublicKey convert2PublicKey(String keyHexStr)
			throws Exception {
		byte[] keyBytes = toBytes(keyHexStr);
		return convert2PublicKey(keyBytes);
	}

	/**
	 * convert public key to hex(16) bit string
	 * 
	 * @param publicKey
	 * @return hex(16) bit string
	 */
	public static String convert4PublicKey(PublicKey publicKey) {
		return toHexString(publicKey.getEncoded());
	}

	public static PublicKey getPublicKey(InputStream in)
			throws CertificateException {
		CertificateFactory cf = CertificateFactory
				.getInstance(SystemUtil.CERTIFICATEFACTORY_X509);
		X509Certificate oCertServer = (X509Certificate) cf
				.generateCertificate(in);
		PublicKey pubKey = oCertServer.getPublicKey();
		return pubKey;
	}

	/***
	 * 
	 * @param hex
	 *            :hex(16) bit string
	 * @return PublicKey
	 * @throws CertificateException
	 */
	public static PublicKey getPublicKey(String hex)
			throws CertificateException {
		InputStream in = FileUtils.getInputSream2hexString(hex);
		return getPublicKey(in);
	}

	/***
	 * 
	 * @param modulus
	 *            :N
	 * @param publicExponent
	 *            :E
	 * @return
	 * @throws Exception
	 */
	public static PublicKey getPublicKey(String modulus, String publicExponent)
			throws Exception {
		BigInteger m = new BigInteger(modulus);

		BigInteger e = new BigInteger(publicExponent);
		RSAPublicKeySpec keySpec = new RSAPublicKeySpec(m, e);
		KeyFactory keyFactory = KeyFactory
				.getInstance(SystemUtil.KEY_ALGORITHM_RSA);

		PublicKey publicKey = keyFactory.generatePublic(keySpec);
		return publicKey;
	}

	// public static PublicKey getPublicKey(BigInteger m, BigInteger e){
	// RSAPublicKeySpec keySpec = new RSAPublicKeySpec(m, e);
	// KeyFactory keyFactory = KeyFactory
	// .getInstance(SystemUtil.KEY_ALGORITHM_RSA);
	//
	// PublicKey publicKey = keyFactory.generatePublic(keySpec);
	// return publicKey;
	// }
	/***
	 * 
	 * @param modulus
	 * @param ePublicExponent
	 * @return
	 * @throws Exception
	 */
	public static PublicKey getPublicKey(BigInteger modulus,
			BigInteger ePublicExponent) throws Exception {
		RSAPublicKeySpec keySpec = new RSAPublicKeySpec(modulus,
				ePublicExponent);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		PublicKey publicKey = keyFactory.generatePublic(keySpec);

		return publicKey;

	}

	/***
	 * 
	 * @param m
	 * @param publicExponent
	 * @return
	 * @throws Exception
	 */
	public static PublicKey getPublicKey(BigInteger m, byte[] publicExponent)
			throws Exception {
		BigInteger e = new BigInteger(publicExponent);
		return getPublicKey(m, e);
	}

	/**
	 * convert byte array to private key algorithm : RSA
	 * 
	 * @param keyBytes
	 *            byte[]
	 * @return RSAPrivateKey
	 * @throws Exception
	 */
	public static PrivateKey convert2PrivateKey(byte[] keyBytes)
			throws Exception {
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory
				.getInstance(SystemUtil.KEY_ALGORITHM_RSA);// RSA
		PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		return privateKey;
	}

	/***
	 * 
	 * @param keyString
	 *            : hex(16) string
	 * @return
	 * @throws Exception
	 */
	public static PrivateKey convert2PrivateKey(String keyString)
			throws Exception {
		byte[] keyBytes = toBytes(keyString);
		return convert2PrivateKey(keyBytes);
	}

	/***
	 * convert private key to hex bit string
	 * 
	 * @param privateKey
	 * @return keyString : hex(16) string
	 */
	public static String convert4PrivateKey(PrivateKey privateKey) {
		return toHexString(privateKey.getEncoded());
	}

	/**
	 * decrypt,key can be a public key， can also be a private key algorithm :
	 * RSA
	 * 
	 * @param message
	 * @return
	 * @throws Exception
	 */
	public static byte[] decrypt(byte[] message, Key key) throws Exception {
		Cipher cipher = Cipher.getInstance(SystemUtil.KEY_ALGORITHM_RSA);
		cipher.init(Cipher.DECRYPT_MODE, key);
		return cipher.doFinal(message);
	}

	/**
	 * decrypt,key can be a public key， can also be a private key
	 * 
	 * @param message
	 * @return
	 * @throws Exception
	 */
	public static byte[] decrypt(String message, Key key) throws Exception {
		return SystemUtil.decrypt(SystemUtil.toBytes(message), key);
	}

	/**
	 * 解密<br>
	 * 用私钥解密
	 * 
	 * @param data
	 * @param publicKeyStr
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, String publicKeyStr)
			throws Exception {
		// 对密钥解密
		byte[] keyBytes = SystemUtil.toBytes(publicKeyStr);

		// 取得公钥
		PublicKey publicKey = SystemUtil.convert2PublicKey(keyBytes);

		return SystemUtil.decrypt(data, publicKey);
	}

	/**
	 * decrypt use private key to decrypt http://www.5a520.cn
	 * http://www.feng123.com
	 * 
	 * @param data
	 * @param privateKeyStr
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, String privateKeyStr)
			throws Exception {
		byte[] keyBytes = SystemUtil.toBytes(privateKeyStr);
		return decryptByPrivateKey(data, keyBytes);
	}

	public static byte[] decryptByPrivateKey(byte[] data, byte[] keyBytes)
			throws Exception {
		PrivateKey privateKey = SystemUtil.convert2PrivateKey(keyBytes);
		return SystemUtil.decrypt(data, privateKey);
	}

	/***
	 * 
	 * @param data
	 * @param N
	 *            :modulus
	 * @param D
	 *            :private exponent
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, byte[] N, byte[] D)
			throws Exception {
		PrivateKey privateKey = getPrivateKey(N, D);
		return decrypt(data, privateKey);
	}

	/***
	 * 
	 * @param dataHex
	 *            :hex bit string
	 * @param privateKeyStr
	 * @param charSet
	 * @return
	 * @throws UnsupportedEncodingException
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(String dataHex,
			String privateKeyStr) throws UnsupportedEncodingException,
			Exception {
		return decryptByPrivateKey(SystemUtil.toBytes(dataHex), privateKeyStr);
	}

	/**
	 * DES
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptDES(byte[] data, byte[] key) throws Exception {
		// Generate a random number generator which can be trusted
		SecureRandom sr = new SecureRandom();

		DESKeySpec dks = new DESKeySpec(key);

		// Create a key factory, and then use it to convert DESKeySpec to
		// SecretKey
		SecretKeyFactory keyFactory = SecretKeyFactory
				.getInstance(SystemUtil.KEY_ALGORITHM_DES);
		SecretKey securekey = keyFactory.generateSecret(dks);
		Cipher cipher = Cipher.getInstance(SystemUtil.KEY_ALGORITHM_DES);

		cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

		return cipher.doFinal(data);
	}

	/**
	 * DES
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws IOException
	 * @throws Exception
	 */
	public static String decryptDES(String data, String key)
			throws IOException, Exception {
		if (data == null)
			return null;
		byte[] buf = SystemUtil.decodeBase64(data);
		byte[] bt = SystemUtil.decryptDES(buf,
				key.getBytes(SystemUtil.CHARSET_UTF));
		return new String(bt, SystemUtil.CHARSET_UTF);
	}

	/**
	 * encrypt,key can be a public key，can also be a private key algorithm : RSA
	 * 
	 * @param message
	 * @return
	 * @throws Exception
	 */
	public static byte[] encrypt(byte[] message, Key key) throws Exception {
		Cipher cipher = Cipher.getInstance(SystemUtil.KEY_ALGORITHM_RSA);
		cipher.init(Cipher.ENCRYPT_MODE, key);
		return cipher.doFinal(message);
	}

	/**
	 * encrypt,key can be a public key，can also be a private key
	 * 
	 * @param message
	 * @return
	 * @throws Exception
	 */
	public static byte[] encrypt(String message, Key key) throws Exception {
		return SystemUtil.encrypt(
				message.getBytes(SystemUtil.CHARSET_ISO88591), key);
	}

	/**
	 * encrypt use public key
	 * 
	 * @param data
	 * @param publicKeyStr
	 *            : hex bit string
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String publicKeyStr)
			throws Exception {
		byte[] keyBytes = toBytes(publicKeyStr);
		// get public key
		PublicKey publicKey = SystemUtil.convert2PublicKey(keyBytes);
		return SystemUtil.encrypt(data, publicKey);
	}

	/***
	 * 
	 * @param data
	 * @param publicKeyStr
	 *            : hex bit string
	 * @param charSet
	 * @return
	 * @throws UnsupportedEncodingException
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(String data, String publicKeyStr,
			String charSet) throws UnsupportedEncodingException, Exception {
		return encryptByPublicKey(data.getBytes(charSet), publicKeyStr);
	}

	/**
	 * encrypt use private key
	 * 
	 * @param data
	 * @param privateKeyStr
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String privateKeyStr)
			throws Exception {
		byte[] keyBytes = toBytes(privateKeyStr);
		// get private key
		Key privateKey = SystemUtil.convert2PrivateKey(keyBytes);
		return SystemUtil.encrypt(data, privateKey);
	}

	/***
	 * 
	 * @param data
	 * @param privateKeyStr
	 *            : hex bit string
	 * @param charSet
	 * @return
	 * @throws UnsupportedEncodingException
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(String data, String privateKeyStr,
			String charSet) throws UnsupportedEncodingException, Exception {
		return encryptByPrivateKey(data.getBytes(charSet), privateKeyStr);
	}

	/**
	 * DES
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptDES(byte[] data, byte[] key) throws Exception {
		// Generate a random number generator which can be trusted
		SecureRandom sr = new SecureRandom();

		DESKeySpec dks = new DESKeySpec(key);
		// Create a key factory, and then use it to convert DESKeySpec to
		// SecretKey
		SecretKeyFactory keyFactory = SecretKeyFactory
				.getInstance(SystemUtil.KEY_ALGORITHM_DES);
		SecretKey securekey = keyFactory.generateSecret(dks);

		Cipher cipher = Cipher.getInstance(SystemUtil.KEY_ALGORITHM_DES);
		cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

		return cipher.doFinal(data);
	}

	/**
	 * DES
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static String encryptDES(String data, String key) throws Exception {
		byte[] bt = SystemUtil.encryptDES(
				data.getBytes(SystemUtil.CHARSET_UTF),
				key.getBytes(SystemUtil.CHARSET_UTF));
		String strs = SystemUtil.encodeBase64(bt);
		return strs;
	}

	/**
	 * use private key sign algorithm : RSA
	 * 
	 * @param message
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] sign(byte[] message, PrivateKey key) throws Exception {
		Signature signetcheck = Signature
				.getInstance(SystemUtil.SIGNATURE_ALGORITHM);
		signetcheck.initSign(key);
		signetcheck.update(message);
		return signetcheck.sign();
	}

	/**
	 * use private key sign
	 * 
	 * @algorithm : RSA
	 * @param message
	 *            data encrypted
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] sign(String message, PrivateKey key) throws Exception {
		return SystemUtil.sign(message.getBytes(SystemUtil.CHARSET_ISO88591),
				key);
	}

	/**
	 * use private key to generate digit sign
	 * 
	 * @param data
	 *            data encrypted
	 * @param privateKeyStr
	 *            private key
	 * 
	 * @return
	 * @throws Exception
	 */
	public static byte[] sign(byte[] data, String privateKeyStr)
			throws Exception {
		PrivateKey priKey = SystemUtil.convert2PrivateKey(privateKeyStr);
		return SystemUtil.sign(data, priKey);
	}

	/**
	 * 
	 * @param message
	 *            data encrypted
	 * @param privateKeyStr
	 *            hex(16) string
	 * @return
	 * @throws Exception
	 */
	public static byte[] sign(String message, String privateKeyStr)
			throws Exception {
		return sign(toBytes(message), privateKeyStr);
	}

	/**
	 * use public key verify sign
	 * 
	 * @param message
	 * @param signStr
	 * @return
	 * @throws Exception
	 */
	public static boolean verifySign(byte[] message, byte[] signBytes,
			PublicKey key) throws Exception {
		if (message == null || signBytes == null || key == null) {
			return false;
		}
		Signature signetcheck = Signature
				.getInstance(SystemUtil.SIGNATURE_ALGORITHM);
		signetcheck.initVerify(key);
		signetcheck.update(message);
		return signetcheck.verify(signBytes);
	}

	public static boolean verifySign(byte[] message, String signStr,
			PublicKey key) throws Exception {
		byte[] signBytes = toBytes(signStr);
		return verifySign(message, signBytes, key);
	}

	/**
	 * use public key verify sign
	 * 
	 * @algorithm : RSA
	 * @param message
	 *            data encrypted
	 * @param signStr
	 * @return
	 * @throws Exception
	 */
	public static boolean verifySign(String message, String signStr,
			PublicKey key) throws Exception {
		return SystemUtil.verifySign(
				message.getBytes(SystemUtil.CHARSET_ISO88591),
				toBytes(signStr), key);
	}

	/**
	 * verify digit sign
	 * 
	 * @param data
	 *            date encrypted
	 * @param publicKeyStr
	 * @param sign
	 * 
	 * @return success:true ;fail:false
	 * @throws Exception
	 * 
	 */
	public static boolean verify(byte[] data, String publicKeyStr, String sign)
			throws Exception {
		// get public key
		PublicKey pubKey = SystemUtil.convert2PublicKey(publicKeyStr);

		return SystemUtil.verifySign(data, sign, pubKey);
	}

	/***
	 * convert hex(16) bit string to byte array
	 * 
	 * @param sHex
	 *            : hex(16) bit string
	 * @return byte[]
	 */
	public static final byte[] toBytes(String sHex) {
		int length = sHex.length();
		if (length % 2 != 0) {
			String message = "Hex  bit string length must be even";
			System.err.println(message);
			throw new RuntimeException(message);
		}
		byte[] bytes;
		bytes = new byte[sHex.length() / 2];
		for (int i = 0; i < bytes.length; i++) {
			bytes[i] = (byte) Integer.parseInt(
					sHex.substring(2 * i, 2 * i + 2), 16);
		}
		return bytes;
	}

	/***
	 * convert byte array to hex(16) bit string
	 * 
	 * @param byte[]
	 * @return hex(16) bit string
	 */
	public static String toHexString(byte[] b) {
		StringBuilder sb = new StringBuilder(b.length * 2);
		for (int i = 0; i < b.length; i++) {
			sb.append(HEXCHAR[(b[i] & 0xf0) >>> 4]);
			sb.append(HEXCHAR[b[i] & 0x0f]);
		}
		return sb.toString();
	}

	/**
	 * 
	 * @param byte[]
	 * @return
	 * @throws UnsupportedEncodingException
	 */
	public static String toString(byte[] b) throws UnsupportedEncodingException {
		return new String(b, CHARSET_ISO88591);
	}

	/**
	 * SHA encrypt
	 * 
	 * @param data
	 * @return byte[]
	 * @throws Exception
	 */
	public static byte[] encryptSHA(byte[] data) throws Exception {

		MessageDigest sha = MessageDigest.getInstance(SystemUtil.KEY_SHA);
		sha.update(data);
		return sha.digest();

	}

	/***
	 * 
	 * @param data
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptSHA(String data) throws Exception {
		return encryptSHA(data.getBytes(SystemUtil.CHARSET_ISO88591));
	}

	/***
	 * sha-1
	 * 
	 * @param data
	 *            byte[]
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptSHA1(byte[] data) throws Exception {

		MessageDigest sha = MessageDigest.getInstance(SystemUtil.KEY_SHA1);
		sha.update(data);
		return sha.digest();

	}

	/***
	 * sha-1
	 * 
	 * @param data
	 *            :String
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptSHA1(String data) throws Exception {
		return encryptSHA1(data.getBytes(SystemUtil.CHARSET_ISO88591));
	}

	/***
	 * 
	 * @param secretKey
	 * @param input
	 * @param algorithm
	 * @return byte[]
	 * @throws Exception
	 */
	public static byte[] getHMAC(byte[] secretKey, byte[] input,
			String algorithm) throws Exception {
		Mac mac = Mac.getInstance(algorithm);
		// get the bytes of the hmac key and data string
		SecretKey secret = new SecretKeySpec(secretKey, algorithm);
		mac.init(secret);
		// 对input 进行HMAC 加密
		byte[] bytesF1 = mac.doFinal(input);
		return bytesF1;
	}

	/***
	 * HMACSHA256
	 * 
	 * @param secretKey
	 * @param input
	 * @return
	 * @throws Exception
	 */
	public static byte[] getHMAC_SHA256(byte[] secretKey, byte[] input)
			throws Exception {
		return getHMAC(secretKey, input, SystemUtil.KEY_HMAC_SHA256);
	}

	/***
	 * HmacSHA1
	 * 
	 * @param secretKey
	 * @param input
	 * @return
	 * @throws Exception
	 */
	public static byte[] getHMAC_SHA1(byte[] secretKey, byte[] input)
			throws Exception {
		return getHMAC(secretKey, input, SystemUtil.KEY_HMAC_SHA1);
	}

	/***
	 * 
	 * @param secretKey
	 *            : hex bit string
	 * @param input
	 *            : hex bit string
	 * @return byte array
	 * @throws Exception
	 */
	public static byte[] getHMAC_SHA1(String secretKey, String input)
			throws Exception {
		return getHMAC_SHA1(SystemUtil.toBytes(secretKey),
				SystemUtil.toBytes(input));
	}

	/***
	 * 
	 * @param keyInfo
	 * @return
	 * @throws NoSuchAlgorithmException
	 * @throws UnsupportedEncodingException
	 */
	public static KeyPair getKeyPair(String keyInfo)
			throws NoSuchAlgorithmException, UnsupportedEncodingException {
		return getKeyPair(keyInfo.getBytes(SystemUtil.CHARSET_ISO88591));
	}

	/***
	 * 
	 * @param keyInfo
	 * @return
	 * @throws NoSuchAlgorithmException
	 * @throws UnsupportedEncodingException
	 */
	public static KeyPair getKeyPair(byte[] keyInfo)
			throws NoSuchAlgorithmException, UnsupportedEncodingException {
		KeyPairGenerator keygen = KeyPairGenerator
				.getInstance(SystemUtil.KEY_ALGORITHM_RSA);
		SecureRandom random = new SecureRandom();
		random.setSeed(keyInfo);
		// 初始加密，长度为512，必须是大于512才可以的
		keygen.initialize(512, random);
		// 取得密钥对
		KeyPair kp = keygen.generateKeyPair();
		return kp;
	}

	/***
	 * 
	 * @param modulus
	 *            :N
	 * @param privateExponent
	 *            :D
	 * @return
	 * @throws Exception
	 */
	public static PrivateKey getPrivateKey(String modulus,
			String privateExponent) throws Exception {

		BigInteger m = new BigInteger(modulus);

		BigInteger D = new BigInteger(privateExponent);

		RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(m, D);

		KeyFactory keyFactory = KeyFactory
				.getInstance(SystemUtil.KEY_ALGORITHM_RSA);

		PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

		return privateKey;

	}

	/***
	 * 
	 * @param m
	 *            : modulus
	 * @param d
	 *            :private exponent
	 * @return
	 * @throws Exception
	 */
	public static PrivateKey getPrivateKey(BigInteger m, BigInteger d)
			throws Exception {
		RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(m, d);

		KeyFactory keyFactory = KeyFactory
				.getInstance(SystemUtil.KEY_ALGORITHM_RSA);
		PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

		return privateKey;

	}

	// public static PrivateKey getPrivateKey(byte[] N_hex, byte[] D_hex){
	// return SystemUtil.getPrivateKey(new BigInteger(N_hex), new
	// BigInteger(D_hex));
	// }
	/***
	 * 
	 * @param m
	 * @param privateExponent
	 *            :D
	 * @return
	 * @throws Exception
	 */
	public static PrivateKey getPrivateKey(BigInteger m, byte[] privateExponent)// TODO
			throws Exception {
		BigInteger d = new BigInteger(privateExponent);
		return getPrivateKey(m, d.negate());
	}

	public static PrivateKey getPrivateKey(byte[] m, byte[] privateExponent)
			throws Exception {
		return getPrivateKey(SystemUtil.getBigIntegerByByteArr(m),
				SystemUtil.getBigIntegerByByteArr(privateExponent));
	}

	/***
	 * OK
	 * 
	 * @param publicKey
	 * @param priKey
	 * @return
	 * @throws Exception
	 */
	public static boolean verifyPrivPubKey(PublicKey publicKey,
			PrivateKey priKey) throws Exception {
		String message = "3234";
		RSAPublicKey rsaPublKey = (RSAPublicKey) publicKey;
		RSAPrivateKey rsaPriKey = (RSAPrivateKey) priKey;
		byte[] encryptBytes = SystemUtil.encrypt(message, publicKey);
		byte[] decryptBytes = SystemUtil.decrypt(encryptBytes, priKey);
		return new String(decryptBytes, SystemUtil.CHARSET_ISO88591)
				.equals(message)
				&& rsaPriKey.getModulus().equals(rsaPublKey.getModulus());
	}

	/***
	 * OK
	 * 
	 * @param m
	 *            :modulus
	 * @param e
	 *            :public key publicExponent
	 * @param d
	 *            :private exponent
	 * @return
	 * @throws Exception
	 */
	public static boolean verifyPrivPubKey(BigInteger modulus,
			BigInteger publicExponent, BigInteger privateExponent)
			throws Exception {
		PublicKey pubKey = getPublicKey(modulus, publicExponent);
		PrivateKey priKey = getPrivateKey(modulus, privateExponent);
		return SystemUtil.verifyPrivPubKey(pubKey, priKey);
	}

	public static boolean verifyPrivPubKey(String modulus_decimal,
			String publicExponent_decimal, String privateExponent_decimal)
			throws Exception {
		BigInteger modulus = new BigInteger(modulus_decimal);
		BigInteger publicExponent = new BigInteger(publicExponent_decimal);
		BigInteger privateExponent = new BigInteger(privateExponent_decimal);
		return verifyPrivPubKey(modulus, publicExponent, privateExponent);
	}

	/***
	 * convert byte array to BigInteger
	 * 
	 * @param bytes
	 * @return
	 */
	public static BigInteger getBigIntegerByByteArr(byte[] bytes) {
		return new BigInteger(SystemUtil.toHexString(bytes), 16);
	}

	/***
	 * convert BigInteger to byte array
	 * 
	 * @param bi
	 * @return
	 */
	public static byte[] getBytesByBigInteger(BigInteger bi) {
		String hexString = bi.toString(16);
		return SystemUtil.toBytes(hexString);
	}

	/***
	 * get prime number
	 * 
	 * @param base
	 * @return
	 */
	// public static int generatePrime(int base) {
	// for (int i = base;; i++) {
	// if (isPrime(i)) {
	// return i;
	// }
	// }
	// }
	public static BigInteger generatePrime(int base) {
		return generatePrime(BigInteger.valueOf(base));
	}

	/***
	 * get prime number which >=base
	 * 
	 * @param base
	 * @return BigInteger
	 */
	public static BigInteger generatePrime(BigInteger base) {
		BigInteger bigInt1 = BigInteger.valueOf(1l);
		for (BigInteger i = base;; i = i.add(bigInt1)) {
			if (isPrime(i)) {
				return i;
			}
		}
	}

	/***
	 * whether is a prime number
	 * 
	 * @param num
	 * @return
	 */
	public static boolean isPrime(int num) {
		return isPrime(BigInteger.valueOf(num));
		// boolean isPrime = true;
		// for (int i = 2; i <= num / 2; i++) {
		// if (num % i == 0) {
		// isPrime = false;
		// break;
		// }
		// }
		// return isPrime;
	}

	/***
	 * whether is a prime number
	 * 
	 * @param num
	 * @return
	 */
	public static boolean isPrime(BigInteger num) {
		boolean isPrime = true;
		BigInteger bigIntTwo = BigInteger.valueOf(2l);
		BigInteger bigIntOne = BigInteger.valueOf(1l);
		for (BigInteger i = bigIntTwo; num.divide(bigIntTwo).compareTo(i) >= 0; i = i
				.add(bigIntOne)) {
			if (num.mod(i).intValue() == 0) {
				isPrime = false;
				break;
			}
		}
		return isPrime;
	}

	/***
	 * 
	 * @param ta
	 * @param isAdd
	 */
	public static void addSubduction(JTextArea ta, boolean isAdd) {
		String argument1 = ta.getText();
		BigInteger bigIntArg1 = new BigInteger(argument1);
		if (isAdd) {
			ta.setText(bigIntArg1.add(bigInt1).toString());
		} else {
			ta.setText(bigIntArg1.subtract(bigInt1).toString());
		}
	}

	/***
	 * 
	 * @param ta
	 * @return
	 */
	public static BigInteger getBigInteger(JTextArea ta) {
		String data = ta.getText();
		return new BigInteger(data);
	}

	/***
	 * 
	 * @param arg1
	 * @param arg2
	 * @return
	 */
	public static BigInteger mod(BigInteger arg1, BigInteger arg2) {
		return arg1.mod(arg2);
	}

	/***
	 * 
	 * @param ta1
	 * @param ta2
	 * @return
	 */
	public static BigInteger mod(JTextArea ta1, JTextArea ta2) {
		BigInteger arg1 = new BigInteger(ta1.getText());
		BigInteger arg2 = new BigInteger(ta2.getText());
		return mod(arg1, arg2);
	}

	/***
	 * 
	 * @param ta1
	 * @param ta2
	 * @return
	 */
	public static BigInteger mod(JTextField ta1, JTextField ta2) {
		BigInteger arg1 = new BigInteger(ta1.getText());
		BigInteger arg2 = new BigInteger(ta2.getText());
		return mod(arg1, arg2);
	}

	/***
	 * convert int to hex string
	 * 
	 * @param bigInt
	 * @return
	 */
	public static String toHexString(BigInteger bigInt) {
		return bigInt.toString(16);
	}

	/***
	 * 
	 * @param ta
	 * @return
	 */
	public static String toHexString(JTextArea ta) {
		BigInteger arg1 = new BigInteger(ta.getText());
		return toHexString(arg1);

	}

	/***
	 * encode by Base64
	 */
	public static String encodeBase64(byte[] input) throws Exception {
		Class clazz = Class
				.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
		Method mainMethod = clazz.getMethod("encode", byte[].class);
		mainMethod.setAccessible(true);
		Object retObj = mainMethod.invoke(null, new Object[] { input });
		return (String) retObj;
	}

	/***
	 * decode by Base64
	 */
	public static byte[] decodeBase64(String input) throws Exception {
		Class clazz = Class
				.forName("com.sun.org.apache.xerces.internal.impl.dv.util.Base64");
		Method mainMethod = clazz.getMethod("decode", String.class);
		mainMethod.setAccessible(true);
		Object retObj = mainMethod.invoke(null, input);
		return (byte[]) retObj;
	}

	/**
	 * 编码
	 * 
	 * @param bstr
	 * @return String
	 */
	public static String encode(byte[] bstr) {
		return new sun.misc.BASE64Encoder().encode(bstr);
	}

	/**
	 * 解码
	 * 
	 * @param str
	 * @return string
	 */
	public static byte[] decode(String str) {
		byte[] bt = null;
		try {
			sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
			bt = decoder.decodeBuffer(str);
		} catch (IOException e) {
			e.printStackTrace();
		}

		return bt;
	}

	/***
	 * 获取实际的子类的class
	 * 
	 * @param clz
	 * @return
	 */
	public static <T> Class<T> getGenricClassType(
			@SuppressWarnings("rawtypes") Class clz) {
		Type type = clz.getGenericSuperclass();
		if (type instanceof ParameterizedType) {
			ParameterizedType pt = (ParameterizedType) type;
			Type[] types = pt.getActualTypeArguments();
			if (types.length > 0 && types[0] instanceof Class) {
				return (Class) types[0];
			}
		}
		return (Class) Object.class;
	}

	// public static byte[] decodeBufferBASE64Decoder(String data) {
	//
	// try {
	// Class clazz = Class.forName("sun.misc.BASE64Decoder");
	// Method mainMethod;
	// mainMethod = clazz.getMethod("decodeBuffer", String.class);
	// mainMethod.setAccessible(true);
	// Object retObj = mainMethod.invoke(clazz.newInstance(), data);
	// return (byte[]) retObj;
	// } catch (SecurityException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (NoSuchMethodException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (IllegalArgumentException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (IllegalAccessException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (InvocationTargetException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (InstantiationException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (ClassNotFoundException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// }
	// return null;
	//
	// }
	//
	// public static String encodeBASE64Encoder(byte[] bt) {
	//
	// try {
	// Class clazz = Class.forName("sun.misc.BASE64Decoder");
	// Method mainMethod;
	// mainMethod = clazz.getMethod("encode", byte[].class);
	// mainMethod.setAccessible(true);
	// Object retObj = mainMethod.invoke(clazz.newInstance(), bt);
	// return (String) retObj;
	// } catch (SecurityException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (NoSuchMethodException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (IllegalArgumentException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (IllegalAccessException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (InvocationTargetException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (InstantiationException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// } catch (ClassNotFoundException e) {
	// // TODO Auto-generated catch block
	// e.printStackTrace();
	// }
	// return null;
	//
	// }
	/***
	 * print byte array
	 * 
	 * @param bytes
	 * @param isNeedPlus
	 *            : Whether to add a plus sign
	 * @return such as
	 *         "[ 52, 116, -18, 34, 70, -43,  56, -60, 17, -67, -52, -97 ] ;length:16"
	 */
	public static String printBytes(byte[] bytes, boolean isNeedPlus) {
		StringBuffer sb = new StringBuffer("[ ");
		for (int i = 0; i < bytes.length; i++) {

			if (bytes[i] > 0 && isNeedPlus) {
				sb.append("+" + String.valueOf(bytes[i]));
			} else {
				sb.append(bytes[i]);
			}
			if (i < bytes.length - 1) {
				sb.append(", ");
			}
		}
		sb.append(" ]").append(" ;length:" + bytes.length);
		return sb.toString();
	}

	/***
	 * Format a byte array
	 * 
	 * @param bytes
	 * @return
	 */
	public static String formatBytes(byte[] bytes) {
		return printBytes(bytes, false);
	}

	/***
	 * Format a byte array
	 * 
	 * @param hex
	 * @return
	 */
	public static String formatBytes(String hex) {
		return formatBytes(SystemUtil.toBytes(hex));
	}

	/***
	 * 
	 * @param bytes
	 */
	public static void printBytes(byte[] bytes) {
		System.out.println(formatBytes(bytes));
	}

	/***
	 * 
	 * @param hex
	 */
	public static void printBytes(String hex) {
		System.out.println(formatBytes(hex));
	}

	/***
	 * 合并字节数组
	 * 
	 * @param a
	 * @return
	 */
	public static byte[] mergeArray(byte[]... a) {
		// 合并完之后数组的总长度
		int index = 0;
		int sum = 0;
		for (int i = 0; i < a.length; i++) {
			sum = sum + a[i].length;
		}
		byte[] result = new byte[sum];
		for (int i = 0; i < a.length; i++) {
			int lengthOne = a[i].length;
			if (lengthOne == 0) {
				continue;
			}
			// 拷贝数组
			System.arraycopy(a[i], 0, result, index, lengthOne);
			index = index + lengthOne;
		}
		return result;
	}

	/***
	 * merge two int array to a string
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	public static String merge(int[] a, int[] b) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < a.length; i++) {
			sb.append(a[i]);
			sb.append(",");
		}
		for (int i = 0; i < b.length; i++) {
			sb.append(b[i]);
			sb.append(",");
		}
		int leng_str = sb.toString().length();
		return sb.substring(0, leng_str - 1);
	}

	/***
	 * Get top <code>frontNum</code> bytes
	 * 
	 * @param source
	 * @param frontNum
	 * @return
	 */
	public static byte[] getFrontBytes(byte[] source, int frontNum) {
		byte[] frontBytes = new byte[frontNum];
		System.arraycopy(source, 0, frontBytes, 0, frontNum);
		return frontBytes;
	}

	public static byte[] getAfterBytes(byte[] source, int afterNum) {
		int length = source.length;
		byte[] afterBytes = new byte[afterNum];
		System.arraycopy(source, length - afterNum, afterBytes, 0, afterNum);
		return afterBytes;
	}

	/***
	 * 
	 * @param frontNum
	 * @param source
	 * @return
	 */
	public static byte[] filterFrontBytes(int frontNum, byte[] source) {
		return copyByte(frontNum, source.length - frontNum, source);
	}

	public static byte[] copyByte(int start, int length, byte[] source) {
		byte[] des = new byte[length];
		System.arraycopy(source, start, des, 0, length);
		return des;
	}

	public static boolean arrayIsEqual(byte[] a, byte[] b) {
		if (a != null && b != null) {
			if (a.length != b.length) {
				return false;
			} else {
				for (int i = 0; i < a.length; i++) {
					if (a[i] != b[i]) {
						return false;
					}
				}
			}
		}
		return true;
	}

	/***
	 * Delete the slash which is in front of input
	 * 
	 * @param input
	 * @return
	 */
	public static String deleteFrontSlash(String input) {
		String result = input.replaceAll("^/", "");
		return result;
	}

	/***
	 * Delete the brackets
	 * 
	 * @param input
	 * @return
	 */
	public static String deletebrackets(String input) {
		input = input.replaceAll("\\[?(.*)\\]?", "$1");
		return input;
	}

	/***
	 * Delete the curly braces ({ })
	 * 
	 * @param input
	 * @return
	 */
	public static String deleteCurlyBraces(String input) {
		input = input.replaceAll("\\{?(.*)\\}", "$1");
		return input;
	}

	public static String deleteSingleQuotes(String input) {
		input = input.replaceAll("'?(.*)'", "$1");
		return input;
	}

	/***
	 * 以斜杠和?分割，获取最后一个 / ? input
	 * :http://localhost:8081/SSLServer/addUser.security?a=b
	 * result:addUser.security
	 */
	public static String getSerlvetNameByQuestionMark(String url) {
		String input = null;
		input = url.replaceAll(".*/([\\w\\.]*)(\\?.*)?$", "$1");
		return input;
	}

	/***
	 * input :http://localhost:8081/SSLServer/addUser.security?a=b
	 * result:addUser
	 */
	public static String getSerlvetName(String url) {
		String input = null;
		input = url.replaceAll(".*/([\\w\\.]*)(\\..*)$", "$1");
		if (input.contains("?")) {
			input = getSerlvetNameByQuestionMark(input);
		}
		return input;
	}

	/***
	 * get port
	 * 
	 * @param url
	 *            such as http://localhost:8081/SSLServer/addUser.A?a=b
	 * @return 8081
	 * 
	 */
	public static String getHttpPort(String url) {
		String input = url.replaceAll("^.+:([\\d]+)/.*$", "$1");
		return input;
	}

	/***
	 * 
	 * 
	 * @param url
	 *            such as localhost/SSLServer/addUser.A?a=b
	 * @return SSLServer
	 */
	public static String getProjectName(String url) {
		String input = url.replaceAll("^.+(:[\\d]+)?/(.*)/.*$", "$2");
		return input;
	}

	/***
	 * get Http request ip
	 * 
	 * @param url
	 * @return
	 */
	public static String getHttpIp(String url) {
		String input = url.replaceAll("^(.*://)?([^/:]*)(:[\\d]+)?/.*$", "$2");
		return input;
	}

	/***
	 * be similar to grep in linux os
	 * 
	 * @param keyWord
	 * @param input
	 *            :List
	 * @return
	 */
	public static List<String> grepStr(String keyWord, String input) {
		String regex = ".*" + keyWord + ".*";
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(input);
		List<String> grepResult = new ArrayList<String>();
		if (m.find()) {
			grepResult.add(m.group());
		}
		return grepResult;
	}

	/****
	 * old:java.lang.String ; result: String
	 * 
	 * @param input
	 * @return
	 */
	public static String getLastNameByPeriod(String input) {
		input = input.replaceAll("^.*\\.([\\w]+)", "$1");
		return input;
	}

	/***
	 * 
	 * @param input
	 *            :2013-06-15
	 * @return
	 */
	public static boolean isDate(String input) {
		String regex = "[\\d]{4}-[\\d]{1,2}-[\\d]{1,2}";
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(input);
		return m.matches();
	}

	public static String grepSimple(String keyWord, String input) {
		List<String> grepResult = grepStr(keyWord, input);
		if (grepResult.size() > 0) {
			return grepResult.get(0);
		} else {
			return null;
		}
	}

	public static int indexOf(String hexStr, String keyWord) {
		return hexStr.indexOf(keyWord.toLowerCase()) / 2;
	}

	public static int indexOf(byte[] bytes, String keyWord) {
		return indexOf(SystemUtil.toHexString(bytes), keyWord.toLowerCase());
	}

	public static int indexOf(byte[] bytes, byte[] keyWord) {
		return indexOf(SystemUtil.toHexString(bytes),
				SystemUtil.toHexString(keyWord).toLowerCase());
	}

	/**
	 * 
	 * The number of occurrences of find keyword in srcText
	 * 
	 * @param srcText
	 * @param keyword
	 * @return
	 */
	public static int findStr1(String srcText, String keyword) {
		int count = 0;
		int leng = srcText.length();
		int j = 0;
		for (int i = 0; i < leng; i++) {
			if (srcText.charAt(i) == keyword.charAt(j)) {
				j++;
				if (j == keyword.length()) {
					count++;
					j = 0;
				}
			} else {
				i = i - j;// should rollback when not match
				j = 0;
			}
		}

		return count;
	}

	public static int findStr2(String srcText, String keyword) {
		int count = 0;
		Pattern p = Pattern.compile(keyword);
		Matcher m = p.matcher(srcText);
		while (m.find()) {
			count++;
		}
		return count;
	}

	public static int findStr3(String srcText, String keyword) {
		return findStr(srcText, keyword, 0);
	}

	public static int findStr(String srcText, String keyWord, int pos) {
		int i, j, k = 0;
		i = pos;
		j = 0;
		while (i < srcText.length() && j < keyWord.length()) {
			if (srcText.charAt(i) == keyWord.charAt(j)) {
				++i;
				++j;
				if (j == keyWord.length()) {
					k = k + 1;// k++
					j = 0;
				}
			} else {
				i = i - j + 1;
				j = 0;
			}
		}
		return k;
	}

	/***
	 * 
	 * @param source
	 * @param findTarget
	 *            :key word
	 * @param pos
	 *            :where start from
	 * @return index
	 */
	public static int findBytes(byte[] source, byte[] findTarget, int pos) {
		int i, j, k = 0;
		i = pos;
		j = 0;
		while (i < source.length && j < findTarget.length) {
			if (source[i] == findTarget[j]) {
				++i;
				++j;
				if (j == findTarget.length) {
					k = k + 1;// k++
					break;
					// j = 0;
				}
			} else {
				i = i - j + 1;
				j = 0;
			}
		}
		return k == 0 ? -1 : i - j;
	}

	/***
	 * start from 0
	 * 
	 * @param source
	 * @param findTarget
	 * @return
	 */
	public static int findBytes(byte[] source, byte[] findTarget) {
		return findBytes(source, findTarget, 0);
	}

	// / <summary>
	// / 判断两个byte[]包含的值是否相等
	// / </summary>
	// / <param name="bytes1">byte[] 1</param>
	// / <param name="bytes2">byte[] 2</param>
	// / <returns>相等返回True,反之False</returns>
	public static boolean isEqualBytes(byte[] bytes1, byte[] bytes2) {
		// 比较长度是否一样
		if (bytes1.length != bytes2.length) {
			return false;
		}
		// 比较成员是否对应相等
		for (int i = 0; i < bytes1.length; i++) {
			if (bytes1[i] != bytes2[i]) {
				return false;
			}
		}
		return true;
	}

	/***
	 * compare tow byte[]
	 * 
	 * @param bytes1
	 * @param bytes2
	 * @return
	 */
	public static boolean isEquals(byte[] bytes1, byte[] bytes2) {
		if (bytes1 == bytes2 && bytes1 == null) {
			return true;
		} else {
			if (bytes1.length != bytes2.length) {
				return false;
			} else {
				int index = findBytes(bytes1, bytes2, 0);
				if (index == -1) {
					return false;
				} else {
					return true;
				}
			}
		}
	}

	public static boolean isEqualChars(char[] chars1, char[] chars2) {
		// 比较长度是否一样
		if (chars1.length != chars2.length) {
			return false;
		}
		// 比较成员是否对应相等
		for (int i = 0; i < chars1.length; i++) {
			if (chars1[i] != chars2[i]) {
				return false;
			}
		}
		return true;
	}

	/***
	 * //
	 * D:\xxx\eclipse\workspace\.metadata\.plugins\org.eclipse.wst.server.core
	 * \tmp0\wtpwebapps\shop_goods\images //
	 * D:\xxx\eclipse\workspace\shop_goods\ upload
	 * 
	 * @param realPath2
	 * @param projectName
	 * @return
	 */
	public static String getRealPath(String realPath2, String projectName) {
		String realpath = realPath2.replaceAll(".metadata.*(" + projectName
				+ ")", "$1");
		return realpath;
	}

	/***
	 * java web //
	 * D:\xxx\eclipse\workspace\.metadata\.plugins\org.eclipse.wst.server
	 * .core\tmp0\wtpwebapps\shop_goods\images //
	 * D:\xxx\eclipse\workspace\shop_goods\ upload
	 * 
	 * @param uploadFolderName
	 * @param projectName
	 * @param sContext
	 * @return
	 */
	public static String getUploadedPath(String uploadFolderName,
			String projectName, ServletContext sContext) {
		String uploadFolder_tmp = null;
		if (uploadFolderName.startsWith("/")) {
			uploadFolder_tmp = uploadFolderName;
		} else {
			uploadFolder_tmp = "/" + uploadFolderName;// "/upload"
		}
		String realpath = sContext.getRealPath(uploadFolder_tmp);
		// project name ,eg.shop_goods
		projectName = SystemUtil.deleteFrontSlash(projectName);
		realpath = SystemUtil.getRealPath(realpath, projectName);
		return realpath;
	}

	/***
	 * download file
	 * 
	 * @param response
	 * @param downloadFilePath
	 * @param filename
	 * @throws IOException
	 */
	public static void downloadFile(HttpServletResponse response,
			File downloadFilePath, String filename) throws IOException {
		FileInputStream fin = new FileInputStream(downloadFilePath);
		// 以流的形式下载文件。
		InputStream fis = new BufferedInputStream(fin);
		byte[] buffer = new byte[fis.available()];
		fis.read(buffer);
		fis.close();
		// 清空response
		response.reset();
		// 设置response的Header
		if (filename == null) {
			filename = downloadFilePath.getName();
		}
		response.addHeader("Content-Disposition", "attachment;filename="
				+ new String(filename.getBytes()));
		response.addHeader("Content-Length", "" + downloadFilePath.length());
		OutputStream toClient = new BufferedOutputStream(
				response.getOutputStream());
		response.setContentType("application/octet-stream");
		toClient.write(buffer);
		toClient.flush();
		toClient.close();

	}

	/***
	 * download file
	 * 
	 * @param response
	 * @param downloadFilePath
	 * @throws IOException
	 */
	public static void downloadFile(HttpServletResponse response,
			File downloadFilePath) throws IOException {
		downloadFile(response, downloadFilePath, null);
	}

	/***
	 * convert List to String[]
	 * 
	 * @param list
	 * @return
	 */
	public static String[] list2Array(List<String> list) {
		return list.toArray(new String[list.size()]);
	}

	/***
	 * print per
	 * 
	 * @param strs
	 */
	public static void printArray(Object[] strs, boolean isNewLine,
			String delimiter) {
		List<Object> list = Arrays.asList(strs);
		printList(list, isNewLine, delimiter);
		// for(int i=0;i<strs.length;i++){
		// System.out.println(strs[i]);
		// }
	}

	public static void printArray(int[] ints) {
		for (int i = 0; i < ints.length; i++) {
			System.out.print(ints[i]);
			if (i < ints.length - 1) {
				System.out.print(" ,");
			}
		}
		System.out.println();
	}

	/***
	 * Print two-dimensional array 0_0 0_1 0_2 0_3 0_4 1_0 1_1 1_2 1_3 1_4
	 * 
	 * @param arrays
	 */
	public

package com.common.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import com.string.widget.util.RandomUtils;

/**
 * Description User: I8800
 */
public class ZipUtil {

	/**
	 * 获得zip压缩包中文件数(包括目录)
	 * 
	 * @param zipFile
	 * @return
	 */
	public static int getFiles(final ZipFile zipFile) {
		return zipFile.size();
	}

	/**
	 * 获得zip压缩包二进制数组中文件数(包括目录)
	 * 
	 * @param zipBytes
	 * @return
	 * @throws IOException
	 */
	public static int getFiles(final byte[] zipBytes) throws IOException {
		int files = 0;
		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(
				zipBytes);
		ZipInputStream zipInputStream = new ZipInputStream(byteArrayInputStream);
		while (zipInputStream.getNextEntry() != null) {
			files++;
		}
		zipInputStream.closeEntry();
		zipInputStream.close();
		byteArrayInputStream.close();
		return files;
	}

	/**
	 * 获得zip压缩包中文件数(包括目录)
	 * 
	 * @param filename
	 * @return
	 * @throws IOException
	 */
	public static int getFiles(final String filename) throws IOException {
		ZipFile zipFile = new ZipFile(filename);
		int files = getFiles(zipFile);
		zipFile.close();
		return files;
	}

	/**
	 * 获得zip压缩包中文件数(包括目录)
	 * 
	 * @param file
	 * @return
	 * @throws IOException
	 */
	public static int getFiles(final File file) throws IOException {
		ZipFile zipFile = new ZipFile(file);
		int files = getFiles(zipFile);
		zipFile.close();
		return files;
	}

	/**
	 * 从zip包中读取给定文件名的内容
	 * 
	 * @param zipFilename
	 * @param name
	 *            获得内容的文件全文件名 注：大小写敏感
	 * @return
	 * @throws IOException
	 */
	public static byte[] getContent(final String zipFilename, final String name)
			throws IOException {
		ZipFile zipFile = new ZipFile(zipFilename);
		byte[] bytes = getContent(zipFile, name);
		zipFile.close();
		return bytes;
	}

	/**
	 * 从zip包中读取给定文件名的内容
	 * 
	 * @param file
	 * @param name
	 *            获得内容的文件全文件名 注：大小写敏感
	 * @return
	 * @throws IOException
	 */
	public static byte[] getContent(final File file, final String name)
			throws IOException {
		ZipFile zipFile = new ZipFile(file);
		byte[] bytes = getContent(zipFile, name);
		zipFile.close();
		return bytes;
	}

	/**
	 * 从zip包中读取给定文件名的内容
	 * 
	 * @param zipFile
	 * @param name
	 *            获得内容的文件全文件名 注：大小写敏感
	 * @return
	 * @throws IOException
	 */
	public static byte[] getContent(final ZipFile zipFile, final String name)
			throws IOException {
		ZipEntry zipEntry = zipFile.getEntry(name);
		return getContent(zipFile, zipEntry);
	}

	/**
	 * 从zip包中读取给定文件名的内容
	 * 
	 * @param zipFile
	 * @param zipEntry
	 * @return
	 * @throws IOException
	 */
	public static byte[] getContent(final ZipFile zipFile,
			final ZipEntry zipEntry) throws IOException {
		InputStream inputStream = zipFile.getInputStream(zipEntry);
		byte[] buffer = new byte[1024];
		byte[] bytes = new byte[0];
		int length;
		while ((length = (inputStream.read(buffer))) != -1) {
			byte[] readBytes = new byte[length];
			System.arraycopy(buffer, 0, readBytes, 0, length);
			bytes = SystemUtil.mergeArray(bytes, readBytes);
		}
		inputStream.close();
		return bytes;
	}

	/**
	 * 从二进制zip包byte数组中获取给定文件名的内容
	 * 
	 * @param zipBytes
	 * @param name
	 * @return
	 * @throws IOException
	 * @throws InterruptedException
	 */
	public static byte[] getContent(final byte[] zipBytes, final String name)
			throws IOException, InterruptedException {
		File file = File.createTempFile(RandomUtils.getTimeRandom(), "."
				+ "zip");
		FileOutputStream fileOutputStream = new FileOutputStream(file);
		fileOutputStream.write(zipBytes);
		fileOutputStream.flush();
		fileOutputStream.close();
		byte[] bytes = getContent(file, name);
		file.delete();
		return bytes;
	}

	/**
	 * @param zipFilename
	 * @param filename
	 * @throws IOException
	 */
	public static void add(final String zipFilename, final String filename)
			throws IOException {
		File zipFile = new File(zipFilename);
		File file = new File(filename);
		add(zipFile, file);
	}

	/**
	 * @param zipFile
	 * @param file
	 * @throws IOException
	 */
	public static void add(final File zipFile, final File file)
			throws IOException {
		FileInputStream fileInputStream = new FileInputStream(file);
		int length = fileInputStream.available();
		byte[] bytes = new byte[length];
		fileInputStream.read(bytes);
		fileInputStream.close();
		add(zipFile, file.getName(), bytes);
	}

	/**
	 * @param zipFile
	 * @param filename
	 * @param bytes
	 * @throws IOException
	 */
	public static void add(final File zipFile, final String filename,
			final byte[] bytes) throws IOException {
		ZipFile zip = new ZipFile(zipFile);
		Enumeration entries = zip.entries();
		FileOutputStream outputStream = new FileOutputStream(zipFile, true);
		ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
		while (entries.hasMoreElements()) {
			ZipEntry entry = (ZipEntry) entries.nextElement();
			addEntry(zipOutputStream, entry,
					getContent(zipFile, entry.getName()));
		}
		ZipEntry zipEntry = new ZipEntry(filename);
		addEntry(zipOutputStream, zipEntry, bytes);

		zipOutputStream.flush();
		zipOutputStream.close();

		outputStream.flush();
		outputStream.close();
		zip.close();
	}

	/**
	 * @param zipFile
	 * @param filename
	 * @throws IOException
	 */
	public static void delete(final File zipFile, final String filename)
			throws IOException {
		ZipFile zip = new ZipFile(zipFile);
		Enumeration entries = zip.entries();
		FileOutputStream outputStream = new FileOutputStream(zipFile, true);
		ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
		while (entries.hasMoreElements()) {
			ZipEntry entry = (ZipEntry) entries.nextElement();
			if (!entry.getName().equalsIgnoreCase(filename)) {
				addEntry(zipOutputStream, entry,
						getContent(zipFile, entry.getName()));
			}
		}
		zipOutputStream.flush();
		zipOutputStream.close();

		outputStream.flush();
		outputStream.close();
		zip.close();
	}

	/**
	 * 添加单个ZipEntry
	 * 
	 * @param zipOutputStream
	 * @param zipEntry
	 * @param bytes
	 * @throws IOException
	 */
	private static void addEntry(ZipOutputStream zipOutputStream,
			ZipEntry zipEntry, byte[] bytes) throws IOException {
		zipOutputStream.putNextEntry(zipEntry);
		zipOutputStream.write(bytes);
		zipOutputStream.flush();
		zipOutputStream.closeEntry();
	}

	/**
	 * 获得zip包中的文件名列表
	 * 
	 * @param zipFile
	 * @return
	 */
	public static List<String> list(final ZipFile zipFile) {
		List<String> list = new ArrayList<String>();
		Enumeration zipEntries = zipFile.entries();
		while (zipEntries.hasMoreElements()) {
			ZipEntry entry = (ZipEntry) zipEntries.nextElement();
			list.add(entry.getName());
		}
		return list;
	}

	/**
	 * 获得zip包中的文件名列表
	 * 
	 * @param file
	 * @return
	 */
	public static List<String> list(final File file) throws IOException {
		ZipFile zipFile = new ZipFile(file);
		List<String> filenameList = list(zipFile);
		zipFile.close();
		return filenameList;
	}

	public static InputStream getInputStreamFromZip(final ZipFile zipFile,
			final String name) throws IOException {
		ZipEntry zipEntry = zipFile.getEntry(name);
		InputStream inputStream = zipFile.getInputStream(zipEntry);
		return inputStream;
	}

	/***
	 * 
	 * @param zipFilename
	 * @param name
	 * @return InputStream
	 * @throws IOException
	 */
	public static InputStream getInputStreamFromZip(final String zipFilename,
			final String name) throws IOException {
		ZipFile zipFile = new ZipFile(zipFilename);
		return getInputStreamFromZip(zipFile, name);
	}

	public static InputStream getInputStreamFromZip(final File file,
			final String name) throws ZipException, IOException {
		ZipFile zipFile = new ZipFile(file);
		return getInputStreamFromZip(zipFile, name);
	}

	/**
	 * 获得zip包中的文件名列表
	 * 
	 * @param filename
	 * @return
	 * @throws IOException
	 */
	public static List<String> list(final String filename) throws IOException {
		File file = new File(filename);
		return list(file);
	}

	/**
	 * 把源文件夹压缩成zip包
	 * 
	 * @param zipFile
	 * @param srcFolder
	 * @throws IOException
	 */
	public static void compress(final File zipFile, final String srcFolder)
			throws IOException {
		File folder = new File(srcFolder);
		FileOutputStream fileOutputStream = new FileOutputStream(zipFile);
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
				fileOutputStream);
		ZipOutputStream zipOutputStream = new ZipOutputStream(
				bufferedOutputStream);
		if (!folder.isDirectory()) {
			compress(zipOutputStream, folder, srcFolder);
		} else {
			List<String> filenameList = listFilename(srcFolder);
			for (String filename : filenameList) {
				File file = new File(filename);
				compress(zipOutputStream, file, srcFolder);
			}
		}
		zipOutputStream.flush();
		zipOutputStream.close();
		bufferedOutputStream.flush();
		bufferedOutputStream.close();
		fileOutputStream.flush();
		fileOutputStream.close();
	}

	/**
	 * @param zipOutputStream
	 * @param file
	 * @throws IOException
	 */
	private static void compress(final ZipOutputStream zipOutputStream,
			final File file, final String srcFolder) throws IOException {
		FileInputStream fileInputStream = new FileInputStream(file);
		BufferedInputStream bufferedInputStream = new BufferedInputStream(
				fileInputStream, 1024);
		ZipEntry entry = new ZipEntry(file.getPath().substring(
				srcFolder.length() + 1));
		zipOutputStream.putNextEntry(entry);
		byte[] data = new byte[bufferedInputStream.available()];
		bufferedInputStream.read(data);
		zipOutputStream.write(data);
		zipOutputStream.flush();
		bufferedInputStream.close();
		fileInputStream.close();
	}

	/**
	 * 解压zip包到目标目录里面
	 * 
	 * @param zipFile
	 * @param targetFolder
	 * @throws IOException
	 */
	public static void decompress(final File zipFile, final String targetFolder)
			throws IOException {
		List<String> filenameList = list(zipFile);
		for (String filename : filenameList) {
			File file = new File(targetFolder + File.separatorChar + filename);
			if (!file.exists()) {
				File parentPath = file.getParentFile();
				if (!parentPath.exists()) {
					parentPath.mkdirs();
				}
				file.createNewFile();
			}
			write(file, getContent(zipFile, filename));
		}
	}

	/**
	 * 解压zip包二进制数组到目标目录里面
	 * 
	 * @param zipBytes
	 * @param targetFolder
	 * @throws IOException
	 */
	public static void decompress(final byte[] zipBytes,
			final String targetFolder) throws IOException {
		File tempFile = File.createTempFile(RandomUtils.getTimeRandom(), "."
				+ "zip");
		FileOutputStream fileOutputStream = new FileOutputStream(tempFile);
		fileOutputStream.write(zipBytes);
		fileOutputStream.flush();
		fileOutputStream.close();

		System.out.println(tempFile.getPath());
		decompress(tempFile, targetFolder);
		tempFile.delete();
	}

	/**
	 * 写入单个文件
	 * 
	 * @param file
	 * @param bytes
	 * @throws IOException
	 */
	private static void write(final File file, final byte[] bytes)
			throws IOException {
		FileOutputStream fileOutputStream = new FileOutputStream(file);
		fileOutputStream.write(bytes);
		fileOutputStream.flush();
		fileOutputStream.close();
	}

	/**
	 * 遍历出所有的文件名和目录名
	 * 
	 * @param path
	 * @return
	 */
	public static List<String> listFilename(final String path) {
		List<String> list = new ArrayList<String>();
		File folder = new File(path);
		if (folder.isDirectory()) {
			File[] files = folder.listFiles();
			if (files != null && files.length > 0) {
				for (File file : files) {
					if (file.isDirectory()) {
						for (String filename : listFilename(file.getPath())) {
							list.add(filename);
						}
					} else {
						list.add(file.getPath());
					}
				}
			} else {
				list.add(folder.getPath());
			}
		} else {
			list.add(folder.getPath());
		}
		return list;
	}
}

import java.io.IOException;

public class ProcessUtil
{
    private static Process process = null;
    static
    {

    }
    private ProcessUtil()
    {
        throw new Error("Don't let anyone instantiate this class.");
    }

    public static Process getPro(String command) throws IOException
    {
        process = Runtime.getRuntime().exec(command);
        return process;
    }

    public static Process getPro(String[] command) throws IOException
    {
        process = Runtime.getRuntime().exec(command);
        return process;
    }
}