Java Recursive Copy recursiveCopyFile(File srcDir, File destDir)

Description

Recursively copy all files from one directory to another.

License

Open Source License

Return

An array contained each source file which was not successfully copied or null if everything went well

Declaration

public static File[] recursiveCopyFile(File srcDir, File destDir) 

Method Source Code

//package com.java2s;
/*//w  ww. ja  va  2 s.c om
 This file is part of the BlueJ program. 
 Copyright (C) 1999-2009,2014  Michael Kolling and John Rosenberg 
     
 This program is free software; you can redistribute it and/or 
 modify it under the terms of the GNU General Public License 
 as published by the Free Software Foundation; either version 2 
 of the License, or (at your option) any later version. 
     
 This program is distributed in the hope that it will be useful, 
 but WITHOUT ANY WARRANTY; without even the implied warranty of 
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 GNU General Public License for more details. 
     
 You should have received a copy of the GNU General Public License 
 along with this program; if not, write to the Free Software 
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. 
     
 This file is subject to the Classpath exception as provided in the  
 LICENSE.txt file that accompanied this code.
 */

import java.io.*;

import java.util.*;

public class Main {
    /**
     * Recursively copy all files from one directory to another.
     * If destination is a sub directory of source directory then
     * it returns without copying any files.
     *
     * @return An array contained each source file which was
     *         not successfully copied or null if everything went well
     */
    public static File[] recursiveCopyFile(File srcDir, File destDir) {
        if (srcDir == null || destDir == null)
            throw new IllegalArgumentException();

        File parentDir = destDir.getParentFile();

        // check to make sure that the destination is not a subdirectory
        // of the source (which would lead to infinite recursion)
        while (parentDir != null) {
            if (parentDir.equals(srcDir))
                return new File[] { srcDir };

            parentDir = parentDir.getParentFile();
        }

        return actualRecursiveCopyFile(srcDir, destDir);
    }

    private static File[] actualRecursiveCopyFile(File srcDir, File destDir) {
        // remember every file which we don't successfully copy
        List<File> failed = new ArrayList<File>();

        // check whether source and dest are the same
        if (srcDir.getAbsolutePath().equals(destDir.getAbsolutePath()))
            return null;

        if (!srcDir.isDirectory() || !destDir.isDirectory())
            throw new IllegalArgumentException();

        // get all entities in the source directory
        File[] files = srcDir.listFiles();
        if (files == null) {
            return null;
        }
        for (int i = 0; i < files.length; i++) {
            if (files[i] != null) {
                // handle directories by recursively copying
                if (files[i].isDirectory()) {

                    File newDir = new File(destDir, files[i].getName());

                    newDir.mkdir();

                    if (newDir.isDirectory()) {
                        actualRecursiveCopyFile(files[i], newDir);
                    } else {
                        failed.add(files[i]);
                    }
                } else if (files[i].isFile()) {
                    // handle all other files
                    File newFile = new File(destDir, files[i].getName());

                    if (!newFile.exists()) {
                        try {
                            copyFile(files[i], newFile);
                        } catch (IOException ioe) {
                            failed.add(files[i]);
                        }
                    } else {
                        failed.add(files[i]);
                    }
                }
            }
        }

        if (failed.size() > 0)
            return (File[]) failed.toArray(new File[0]);
        else
            return null;
    }

    /**
     * Copy file 'source' to file 'dest'. The source file must exist,
     * the destination file will be created. Returns true if successful.
     */
    public static void copyFile(String source, String dest) throws IOException {
        File srcFile = new File(source);
        File destFile = new File(dest);

        copyFile(srcFile, destFile);
    }

    /**
     * Copy file 'srcFile' to file 'destFile'. The source file must exist,
     * the destination file will be created. Returns true if successful.
     */
    public static void copyFile(File srcFile, File destFile) throws IOException {
        // check whether source and dest are the same
        if (srcFile.equals(destFile)) {
            return; // don't bother - they are the same
        }

        InputStream in = null;
        OutputStream out = null;

        try {
            in = new BufferedInputStream(new FileInputStream(srcFile));
            out = new BufferedOutputStream(new FileOutputStream(destFile));
            copyStream(in, out);
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }

    /**
     * Copy stream 'in' to stream 'out'.
     */
    public static void copyStream(InputStream in, OutputStream out) throws IOException {
        for (int c; (c = in.read()) != -1;)
            out.write(c);
    }
}

Related

1. recursiveCopy(File copyFromDir, File copyToDir, boolean overwrite)
2. recursiveCopy(File sourceFile, File targetLocation)
3. recursiveCopy(File src, File dest)
4. recursiveCopyDir(File source, File destination)