处理文件的工具类

package cn.com.acca.ajaf.common.file;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.apache.tools.zip.ZipOutputStream;

import cn.com.acca.ajaf.common.file.FileUtil;

/**
 * 文件工具类
 * 
 * 
 * 
 */
public enum FileUtil {

	INSTANCE;

	/**
	 * 生成随机的文件名 将原始文件名去掉,改为一个UUID的文件名,后缀名不变
	 * 
	 * @param fileName
	 *            原始文件名+后缀
	 * @return
	 */
	public String generateUUIDFileName(String fileName) {

		UUID uuid = UUID.randomUUID();
		String str = fileName;
		System.out.println(str);
		str = uuid.toString() + "." + str.substring(str.lastIndexOf(".") + 1);
		return str;
	}

	/**
	 * 获得一个文件全路径中的文件名
	 * 
	 * @param filePath
	 *            文件路径
	 * @return 文件名
	 */
	public String getFileName(String filePath) {

		filePath = filePath.replace("\\", "/");
		if (filePath.indexOf("/") != -1) {
			return filePath.substring(filePath.lastIndexOf("/") + 1);
		}
		return filePath;
	}

	/**
	 * 拷贝文件
	 * 
	 * @param src
	 *            源文件
	 * @param dst
	 *            目标文件
	 */
	public void copyFile( File src, File dst) {
		try {
			FileInputStream in = null;
			FileOutputStream out = null;
			try {
				out = new FileOutputStream(dst);
				in = new FileInputStream(src);
				byte[] buffer = new byte[1024];
				int len = 0;
				while ((len = in.read(buffer)) > 0) {
					out.write(buffer, 0, len);
				}
			} catch (Exception e) {
				e.printStackTrace();
				String dstpath = dst.getAbsolutePath();
				if (dstpath.lastIndexOf("/") != -1) {
					dstpath = dstpath.subSequence(0, dstpath.lastIndexOf("/"))
							.toString();
				} else {
					dstpath = dstpath.subSequence(0, dstpath.lastIndexOf("\\"))
							.toString();
				}
				createDirectory(dstpath);
				copyFile(src, dst);
			} finally {
				if (null != in) {
					in.close();
				}
				if (null != out) {
					out.close();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 创建一个文件
	 * @param destFileName
	 * @return
	 */
    public boolean createFile(String destFileName) {
        File file = new File(destFileName);
        if(file.exists()) {
            System.out.println("创建单个文件" + destFileName + "失败，目标文件已存在！");
            return false;
        }
        if (destFileName.endsWith(File.separator)) {
            System.out.println("创建单个文件" + destFileName + "失败，目标文件不能为目录！");
            return false;
        }
        //判断目标文件所在的目录是否存在
        if(!file.getParentFile().exists()) {
            //如果目标文件所在的目录不存在，则创建父目录
            System.out.println("目标文件所在目录不存在，准备创建它！");
            if(!file.getParentFile().mkdirs()) {
                System.out.println("创建目标文件所在目录失败！");
                return false;
            }
        }
        //创建目标文件
        try {
            if (file.createNewFile()) {
                System.out.println("创建单个文件" + destFileName + "成功！");
                return true;
            } else {
                System.out.println("创建单个文件" + destFileName + "失败！");
                return false;
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("创建单个文件" + destFileName + "失败！" + e.getMessage());
            return false;
        }
    }
    
    
    /**
     * 创建目录
     * @param destDirName
     * @return
     */
    public static void createDirectory(String destDirName) {
        File dir = new File(destDirName);
        if (dir.exists()) {
            System.out.println("目标目录已经存在");
            return;
        }
        if (!destDirName.endsWith(File.separator)) {
            destDirName = destDirName + File.separator;
        }
        //创建目录
        if (dir.mkdirs()) {
            System.out.println("创建目录" + destDirName + "成功！");
        } else {
            System.out.println("创建目录" + destDirName + "失败！");
        }
    }
    
    
	/**
	 * 删除文件
	 * 只能删除指定的文件或者指定的空文件夹
	 * @param files
	 */
	public void deleteFile(File... files) {
		if (files == null) {
			return;
		}
		for (File f : files) {
			if (f.exists()) {
				f.delete();
			}else {
				System.out.println("所删除的文件"+f.getAbsolutePath()+"不存在！");
			}
		}
	}

	/**
	 * 删除文件夹
	 * 
	 * @param files
	 */
	public void deleteDirectory(File file) {
		if (file.exists()) { // 判断文件是否存在
			if (file.isFile()) { // 判断是否是文件
				file.delete(); // delete()方法 你应该知道 是删除的意思;
			} else if (file.isDirectory()) { // 否则如果它是一个目录
				File[] files = file.listFiles(); // 声明目录下所有的文件 files[];
				for (int i = 0; i < files.length; i++) { // 遍历目录下所有的文件
					this.deleteDirectory(files[i]); // 把每个文件 用这个方法进行迭代
				}
			}
			file.delete();
		} else {
			System.out.println("所删除的文件"+file.getAbsolutePath()+"不存在！");
		}
	}
	
	/**
	 * 把接受的全部文件打成压缩包
	 * 
	 * @param File[] 文件名数组
	 * @param String 压缩后存放的绝对名称
	 * @throws IOException 
	 */
	public void compressFiles2Zip(List<File> files, String tempZipPathAndName) throws IOException  {
		File zipFile = new File(tempZipPathAndName);
		if (!zipFile.exists()) {
			zipFile.createNewFile();
		}
		FileOutputStream fous = new FileOutputStream(zipFile);
		ZipOutputStream zipOut = new ZipOutputStream(fous);
		int size = files.size();
		for (int i = 0; i < size; i++) {
			File file = (File) files.get(i);
			compressFilesZip(file, zipOut);
		}
		zipOut.close();
		fous.close();
	}

	/**
	 * 根据输入的文件与输出流对文件进行打包
	 * 
	 * @param File
	 * @param org
	 *            .apache.tools.zip.ZipOutputStream
	 * @throws IOException 
	 */
	public void compressFilesZip(File inputFile, ZipOutputStream ouputStream) throws IOException {
		ouputStream.setEncoding("gb2312");
		if (inputFile.exists()) {
			if (inputFile.isFile()) {
				FileInputStream in = new FileInputStream(inputFile);
				BufferedInputStream bins = new BufferedInputStream(in, 512);
				// org.apache.tools.zip.ZipEntry
				ZipEntry entry = new ZipEntry(inputFile.getName());
				ouputStream.putNextEntry(entry);
				// 向压缩文件中输出数据
				int nNumber;
				byte[] buffer = new byte[512];
				while ((nNumber = bins.read(buffer)) != -1) {
					ouputStream.write(buffer, 0, nNumber);
				}
				// 关闭创建的流对象
				bins.close();
				in.close();
			} else {
				File[] files = inputFile.listFiles();
				for (int i = 0; i < files.length; i++) {
					compressFilesZip(files[i], ouputStream);
				}
			}
		}
	}

	/**
	 * 解压ZIP文件
	 * @param archive
	 * @param decompressDir
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public boolean unZip(File archive, String decompressDir) {
		boolean flag = false;
		ZipFile zf = null;
		try {
			BufferedInputStream bi = null;
			zf = new ZipFile(archive, "GBK");// 支持中文
			Enumeration e = zf.getEntries();
			while (e.hasMoreElements()) {
				ZipEntry ze2 = (ZipEntry) e.nextElement();
				String entryName = ze2.getName();
				String path = decompressDir + "/" + entryName;
				if (ze2.isDirectory()) {
					System.out.println("正在创建解压目录 - " + entryName);
					File decompressDirFile = new File(path);
					if (!decompressDirFile.exists()) {
						decompressDirFile.mkdirs();
					}
				} else {
					System.out.println("正在创建解压文件 - " + entryName);
					String fileDir = path.substring(0, path.lastIndexOf("/"));
					File fileDirFile = new File(fileDir);
					if (!fileDirFile.exists()) {
						fileDirFile.mkdirs();
					}
					BufferedOutputStream bos = null;
					try {
						bos = new BufferedOutputStream(new FileOutputStream(
								decompressDir + "/" + entryName));
						bi = new BufferedInputStream(zf.getInputStream(ze2));
						byte[] readContent = new byte[1024];
						int readCount = bi.read(readContent);
						while (readCount != -1) {
							bos.write(readContent, 0, readCount);
							readCount = bi.read(readContent);
						}
						bi.close();
						bos.close();
					} catch (Exception ex) {
						System.out.println("解压缩文件出现异常");
						ex.printStackTrace();
					} finally {
						if (bi != null)
							bi.close();
						if (bos != null)
							bos.close();
					}
				}
			}
			zf.close();
			flag = true;
		} catch (IOException e) {
			System.out.println("解压缩文件出现异常");
		} finally {
			try {
				if (zf != null) {
					zf.close();
				}
			} catch (IOException ex) {
				System.out.println("关闭zipFile出现异常");
			}
		}
		return flag;
	}

	public static FileUtil getInstance() {
		return INSTANCE;
	}


	/**
	 * 文件上传
	 * @throws IOException 
	 * @throws Exception
	 */
	protected void uploadFiles(String srcFileAbsolutePath, String destFileAbsolutePath) throws IOException {
		
		//把要上传的文件转换成输入流
		FileInputStream fis = new FileInputStream(srcFileAbsolutePath);
		/*
		//目的地目录
		File directory = new File(basePath);
		if (!directory.exists())
			directory.mkdirs();
		*/
		//创建目标文件（含目录）
		this.createFile(destFileAbsolutePath);
		
		System.out.println(destFileAbsolutePath);
		
		//输出流到目标文件
		FileOutputStream fos = new FileOutputStream(destFileAbsolutePath);
		
		byte[] buffer = new byte[1024];
		int length;
		while ((length = fis.read(buffer)) > 0) {
			fos.write(buffer, 0, length);
		}
		fis.close();
		fos.close();
	}
	
	/**
	 * 获取指定目录下的文件名列表
	 * 参数：文件目录（绝对目录）
	 * @return 文件名列表数组
	 */
    public List<String> getFileNameList(String directory) {
    	List<String> list = new ArrayList<String>();
    	String[] fileList = new File(directory).list();
    	if(fileList!=null){
            for(String fileName : fileList){
            	String file = directory+File.separator+fileName;
            	if( new File(file).isFile() ){
            		list.add(fileName);
            		System.out.println(file);
            	}
            }
    	}
		return list;
    }
    
	/**
	 * 获取指定目录下的文件目录列表
	 * 参数：文件目录（绝对目录）
	 * @return 文件目录列表数组
	 */
    public List<String> getChildDirectoryList(String directory) {
    	List<String> list = new ArrayList<String>();
        String[] fileList = new File(directory).list();  
        if(fileList!=null){
            for(String fileName : fileList){
            	String file = directory+File.separator+fileName;
            	if( new File(file).isDirectory() ){
            		list.add(file);
            		System.out.println(file);
            	}
            }
        }
		return list;
    }
    
    /**
     * 获取指定文件的属性信息
     * 参数：文件名（绝对名称）
     * @return 文件名(不包含路径名)列表数组
     */
    public void getFilePropertiesByName(String filePath) {
    	 
    	  File file = new File(filePath);
    	  //System.out.println(file.isDirectory());           //测试此抽象路径名表示的文件是否是一个目录。
    	  //System.out.println(file.getAbsoluteFile());           //返回抽象路径名的绝对路径名形式
    	  //System.out.println(file.getAbsolutePath());           //返回抽象路径名的绝对路径名字符串。 
    	  //System.out.println(file.isAbsolute());         //测试此抽象路径名是否为绝对路径名
    	  
    	  long modifyDate = file.lastModified();   //得到最后修改日期
    	  if (modifyDate!=0){
    		 // System.out.println("\n 最后修改日期: "+ new Date(modifyDate).toLocaleString()); //返回此抽象路径名表示的文件最后一次被修改的时间。
    		  System.out.println("\n 最后修改日期: "+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format( modifyDate) ); //返回此抽象路径名表示的文件最后一次被修改的时间。
    	  }
    	  System.out.println("文件大小：" + file.length());                //返回由此抽象路径名表示的文件的长度
    }
       

    /**
     * 根据文件名关键字(忽略大小写，空格分隔)搜索指定目录下的文件名
     * @param args
     * @throws IOException
     */
    public Map<String, String> searchFileByNameKey(String directory, String fileNameKey) {
    	Map<String, String> map = null;
		if(fileNameKey==null){
			return null;
		}
		fileNameKey = fileNameKey.trim();
		//匹配文件名
		if (!"".equals(fileNameKey)) {
			map = new HashMap<String,String>(); 
			String keys[] = fileNameKey.split("\\s");
			//在指定文件目录下，逐个匹配
			String[] fileList = new File(directory).list();
	        for(String keyStr : keys ){
	        	System.out.println(keyStr); //逐个输出数组元素的值
	        	
				for (String file : fileList) {
		             System.out.println(file); //逐个输出数组元素的值
		             if( file.toLowerCase().indexOf(keyStr.toLowerCase())>=0 ){ //匹配
		         		//map.put(file, map.get(file));
		        		if(map.get(file)==null){
		        			map.put(file, String.valueOf(1));
		        		}else{
		        			map.put(file, String.valueOf(Integer.parseInt(map.get(file))+1) );
		        		}
		             }
		        }
	        }
		}
		return map;
    }   
    
    /**
     * 根据文件更新时间关键字(忽略大小写，空格分隔)搜索指定目录下的文件名
     * @param args
     * @throws IOException
     */
    public Map<String, String> searchFileByTimeKey(String directory, String updateTimeKey) {
    	Map<String, String> map = null;
		if(updateTimeKey==null){
			return null;
		}
		updateTimeKey = updateTimeKey.trim();
		//匹配文件名
		if (!"".equals(updateTimeKey.trim())) {
			map = new HashMap<String,String>(); 
			String keys[] = updateTimeKey.split("\\s");
			
			//在指定文件目录下，逐个匹配
			File[] fileList = new File(directory).listFiles();//指定目录下的所有文件名
			
			//long modifyDate = file.lastModified();   //得到最后修改日期
			
	        for(String keyStr : keys ){
	        	System.out.println(keyStr); //逐个输出数组元素的值
	        	
				for (File file : fileList) {
					 String updateTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(file.lastModified());
		             if( updateTime.indexOf(keyStr.toLowerCase())>=0 ){ //匹配
		         		//map.put(file, map.get(file));
		        		if(map.get(file)==null){
		        			map.put(file.getName(), String.valueOf(1));
		        		}else{
		        			map.put(file.getName(), String.valueOf(Integer.parseInt(map.get(file))+1) );
		        		}
		             }
		        }
	        }
		}
		return map;
    }   
    
    
	public static void main(String[] args) throws IOException {
		String path ="D:/demo_download/zip";
		FileUtil.INSTANCE.getChildDirectoryList(path);
		System.out.println("-------------");
		FileUtil.INSTANCE.getFileNameList (path);
	}
}