File练习--实现目录（文件）的复制，剪贴，删除

一个小练习，使用java实现目录（包括文件和子目录或者子文件在内）的复制，剪贴和删除，基本实现思路就是利用递归，由内往外逐级删除。

其实本来是没有想到写这个练习的，谁知道今天写了一个File的demo，产生了bug，导致在一个目录下面新建目录，新建的目录下再新建目录，导致一直到栈内存溢出才停止了。然后手动去尝试删除那些目录的时候问题来了！Windows提示，文件路径长度超过NTFS支持的最大长度，让我手动把最内层的文件夹复制出来，变短一点再删除。尼玛，不停双击再双击，不知道多少层了都找翻不到底层。所以就放弃了，直接写了个demo处理了下这个问题，顺便做了一下练习。

具体代码里面有详细的注释和一些解释，直接复制javac就能跑，删除和剪贴功能清慎用，代码删除是没有办法撤销的，误删要找回来是比较麻烦的。

package file;
/*
 * 递归练习实现目录的删除，复制，剪贴
 */

import java.io.*;

public class Digui {
    public static void main(String[] args) {

        //deleteDir(new File("E:\\demo\\a\\a"));
        //cut(new File("E:\\demo"), new File("E:\\demo1"));
        //copyDir(new File("E:\\demo\\b\\"),new File("E:\\demo1"));
    }
    
    /*
     * 调用删除和复制，实现剪贴
     */
    public static void cut(File dirFrom, File dirTo) {

        // 先复制完成
        copy(dirFrom, dirTo);

        // 删除原目录
        delete(dirFrom);
    }

    /*
     * 递归实现目录的删除（包括目录下的子目录和文件）
     */
    public static void delete(File dir) {

        // 如果传入的对象为空，直接结束方法
        if (dir == null)
            return;
        // 如果传入的目录不存在，直接结束方法
        if (!dir.exists())
            return;
        // 如果是文件，直接删除
        if (dir.isFile()) {
            dir.delete();
            return;
        } else { // 如果是目录，判断是不是空目录，空目录直接删除，不是空目录进去递归调用
            File[] dirs = dir.listFiles();

            if (dirs == null) {
                dir.delete();
                return;
            } else {

                for (File f : dirs) {
                    delete(f);
                }

            }
            //最后再删除父目录本身，因为此时父目录为空，才可以删除
            dir.delete();
        }
    }

    /* 复制目录
     * 
     * 目标：把原目录（包括源目录在内）下的子目录和文件全部复制到新目标目录下
     * 
     * 思路（递归实现目录的复制 ）：
     * 1.方法的前面先 进行健壮性处理，空对象等等
     * 2.然后分情况判断，原目录是一个文件，直接复制完成结束方法，是目录进行以下步骤 
     * 3.获取源目录，创建新目录
     * 4.逐个创建子目录，如果是文件，创建完成后，把数据copy过来
     * 5.如果是子目录是路径，则递归调用方法，传入新的源目录和目标目录file对象，从3开始继续
     * 
     * 健壮性思路：
     * 源目录和目标目录为空对象，直接报runtime异常
     * 源目录和目标目录为同一个对象，直接报runtime异常
     * 目标目录不存在，尝试创建，创建失败报runtime异常，若成功提示新建了目录后继续执行
     * 目标目录是文件时，复制在此文件所在的目录下
     */
    public static void copy(File dirFrom, File dirTo) {

        // 健壮性处理
        // 空对象，直接报错
        if (dirFrom == null || dirTo == null)
            throw new RuntimeException("文件对象为空！");
        // 目标目录的原目录相同，直接返回
        if (dirFrom == dirTo)
            throw new RuntimeException("不能原地复制");
        // 目标目录不存在处理
        if (!dirTo.exists()) {

            if (dirTo.mkdirs()) {
                System.out.println("目标目录不存在，已创建");
            } else {

                throw new RuntimeException("目标目录不存在，尝试创建失败");
            }
        }
        // 目标目录是一个文件，复制在此文件的目录下
        if(dirTo.isFile())
            dirTo = dirTo.getParentFile();

        // 原目录是一个文件,直接把文件复制过去即可
        if (dirFrom.isFile()) {
            BufferedInputStream bis1 = null;
            BufferedOutputStream bos1 = null;
            
            File newFile1 = new File(dirTo, dirFrom.getName());
            
            try {
                newFile1.createNewFile();

                bis1 = new BufferedInputStream(new FileInputStream(dirFrom));
                bos1 = new BufferedOutputStream(new FileOutputStream(newFile1));

                int len1 = 0;
                byte[] data1 = new byte[1024];

                while ((len1 = bis1.read(data1)) != -1) {
                    bos1.write(data1, 0, len1);
                    bos1.flush();
                }

            } catch (IOException e) {  //异常处理，报异常直接结束程序
                throw new RuntimeException("文件复制失败");
            } finally { //关闭流对象
                try {
                    bos1.close();
                } catch (IOException e) {
                    throw new RuntimeException("文件对象关闭失败");
                }

                try {
                    bis1.close();
                } catch (IOException e) {
                    throw new RuntimeException("文件对象关闭失败");
                }
            }
            return; // 因为原file是一个文件，所以复制完成后，直接结束方法
        } else {//原目录不是目录，进入下面的代码
            
            //在目标目录下创建和源目录name相同的file对象，并实例化
            File newCopyDir = new File(dirTo, dirFrom.getName());
            newCopyDir.mkdir();
            
            //获取源目录下的子目录
            File[] fileFrom = dirFrom.listFiles();
            
            //如果源目录是一个空的目录，则直接结束掉方法即可
            //因为上面已经创建了新的目录的，也就是说复制已经完成
            if(fileFrom.length == 0)
                return;

            
            for (File f : fileFrom) {
                if (f.isFile()) {
                    
                    // 判断子目录下的File如果是一个文件，则在新目录下也创建一个相同的文件
                    File newFile = new File(newCopyDir, f.getName());

                    BufferedInputStream bis = null;
                    BufferedOutputStream bos = null;
                    try {
                        newFile.createNewFile();

                        bis = new BufferedInputStream(new FileInputStream(f));
                        bos = new BufferedOutputStream(new FileOutputStream(newFile));

                        int len = 0;
                        byte[] data = new byte[1024];

                        while ((len = bis.read(data)) != -1) {
                            bos.write(data, 0, len);
                            bos.flush();
                        }

                    } catch (IOException e) {
                        throw new RuntimeException("文件复制失败");
                    } finally { //在finally下关闭两个流对象，并做异常处理

                        try {
                            bos.close();
                        } catch (IOException e1) {
                            throw new RuntimeException("文件对象关闭失败");
                        }

                        try {
                            bis.close();
                        } catch (IOException e1) {
                            throw new RuntimeException("文件对象关闭失败");
                        }
                    }
                } else { // 子目录不是一个文件，就采取递归模式，继续进行
                    copy(f, newCopyDir);
                }
            }
        }
    }
    
}