Java的copy文件和文件夹以及删除文件夹(包括递归与非递归算法)

Copy文件算法

 /**
     * <pre>
     * 复制文件
     * 源文件不存在，直接返回
     * 目标文件不存在时，创建父目录
     * </pre>
     *
     * @param srcFile 源文件
     * @param destFile 目标文件
     */
    public static void copy(File srcFile, File destFile) {
        //源文件不存在，直接返回
        if (!srcFile.exists()) {
            logger.info("源文件["+ srcFile.getName() +"]不存在");
            return;
        }
        //目标文件不存在时，创建父目录
        if (!destFile.exists()) {
            logger.info("目标文件["+ destFile.getName() +"]所在的父目录不存在,创建父目录");
            destFile.getParentFile().mkdirs();
        }
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(srcFile);
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream(destFile);
            bos = new BufferedOutputStream(fos);
            byte[] buffer = new byte[1024 * 5];

            int length;
            while ((length = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, length);
            }
            bos.flush();

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
            try {
                if (bis != null) {
                    bis.close();
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
            try {
                if (bos != null) {
                    bos.close();
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
        }
    }

 

Copy目录(递归算法)

/**
	 * 复制目录下的所有到另一目录
	 * @param srcDir
	 * @param destDir
	 */
	public static void copyDir(File srcDir,File destDir){
		//生成目录
		if(!destDir.exists()){
			destDir.mkdirs();
		}
		//循环源目录
		File[]srcFiles = srcDir.listFiles();
		for (int i = 0; i < srcFiles.length; i++) {
			File src = srcFiles[i];
			if(src.isFile()){
				File targetFile = new File(destDir.getAbsolutePath() + "\\" + src.getName());
				copy(src, targetFile);
			}else{
				copyDir(new File(srcDir + "\\" + src.getName()), new File(destDir + "\\" + src.getName()));
			}
		}
	}

 

Copy目录(非递归算法)：

 /**
     * 拷贝目录(非递归)
     * @param srcDir 源目录
     * @param destDir 目标目录
     */
    public static void copyDirNonRecursion(File srcDir, File destDir) {
        //生成目录
        if (!destDir.exists()) {
            logger.info("目标文件["+ destDir.getName() +"]的目录不存在,创建相应目录");
            destDir.mkdirs();
        }

        Stack<File> fileStack = new Stack<File>();
        fileStack.push(srcDir);
        File curFile;
        File preFile = null;
        String parentPath = destDir.getAbsolutePath();
        parentPath = parentPath.replaceAll("[\\\\]", "/");
        String srcPath = srcDir.getAbsolutePath();
        while (!fileStack.empty()) {
            curFile = fileStack.peek();
            File[] fileLists = curFile.listFiles();
            //当前文件为非目录，或者空目录或者前一个文件的父目录为当前文件时
            if (curFile.isFile()
                    || (preFile != null && (preFile.getParent().equals(curFile.getAbsolutePath())))
                    || (fileLists.length == 0)) {
                File popFile = fileStack.pop();
                String filePath = popFile.getAbsolutePath();
                if (filePath.equals(srcPath)) {
                    continue;
                }
                filePath = filePath.replaceAll("[\\\\]", "/");
                filePath = filePath.substring(srcPath.length() + 1);
                filePath = parentPath + "/" + filePath;
                if (popFile.isFile()) {
                    copy(popFile, new File(filePath));
                } else {
                    File dir = new File(filePath);
                    dir.mkdirs();
                }
                preFile = curFile;
            } else {
                for (File file : fileLists) {
                    fileStack.push(file);
                }
            }
        }
    }

 

删除目录（递归算法）

/**
	 * 给入一个目录，删除该目录下的所有文件。
	 * @param dir
	 */
	public static void deleteDir(File dir){
		if(dir.isDirectory()){
			File[] listFiles = dir.listFiles();
			for (int i = 0; i < listFiles.length; i++) {
				File f = listFiles[i];
				if(f.isFile()){
					f.delete();
				} else if(f.isDirectory()){
					deleteDir(f);
				}
			}
			//删除当前目录
			dir.delete();
		}
	}

 

 删除目录(非递归算法)：

    /**
     * 删除目录(非递归)
     * @param srcDir 源目录
     */
    public static void deleteDirNonRecursion(File srcDir) {
        Stack<File> fileStack = new Stack<File>();
        fileStack.push(srcDir);
        File curFile;
        File preFile = null;
        while (!fileStack.empty()) {
            curFile = fileStack.peek();
            File[] fileLists = curFile.listFiles();
            //当前文件为非目录，或者空目录或者前一个文件的父目录为当前文件时
            if (curFile.isFile()
                    || (preFile != null && (preFile.getParent().equals(curFile.getAbsolutePath())))
                    || (fileLists.length == 0)) {
                File popFile = fileStack.pop();
                popFile.delete();
                preFile = curFile;
            } else {
                for (File file : fileLists) {
                    fileStack.push(file);
                }
            }
        }
    }

 

读取目录(非递归算法)：

public void readFile(File rootFile) {
        Stack<File> fileStack = new Stack<File>();
        fileStack.push(rootFile);
        File curFile;
        File preFile = null;
        while (!fileStack.empty()) {
            curFile = fileStack.peek();
            File[] fileLists = curFile.listFiles();
            if (curFile.isFile()
                    || (preFile != null && (preFile.getParent().equals(curFile.getAbsolutePath())))
                    || (fileLists.length == 0)) {
                System.err.println(curFile.getAbsolutePath());
                fileStack.pop();
                preFile = curFile;
            } else {
                for (File file : fileLists) {
                    fileStack.push(file);
                }
            }
        }
    }