Java 8: Copy directory recursively?

Question

I see that Java 8 has significantly cleaned up reading the contents of a file into a String:

String contents = new String(Files.readAllBytes(Paths.get(new URI(someUrl))));

I am wondering if there is something similar (cleaner/less code/more concise) for copying directories recursively. In Java 7 land, it's still something like:

public void copyFolder(File src, File dest) throws IOException{
    if(src.isDirectory()){
        if(!dest.exists()){
            dest.mkdir();
        }

        String files[] = src.list();

        for (String file : files) {
            File srcFile = new File(src, file);
            File destFile = new File(dest, file);

            copyFolder(srcFile,destFile);
        }

    } else {
        InputStream in = new FileInputStream(src);
        OutputStream out = new FileOutputStream(dest); 

        byte[] buffer = new byte[1024];

        int length;
        while ((length = in.read(buffer)) > 0){
            out.write(buffer, 0, length);
        }

        in.close();
        out.close();
    }
}

Any improvements here in Java 8?

FYI `Files.readAllBytes(Paths.get(new URI(someUrl))` is available since Java 7. — assylias, Mar 16 '15 at 12:09
else block can be done with `java.nio.file.Files#copy(java.nio.file.Path, java.nio.file.Path, java.nio.file.CopyOption...)` also available since 1.7 — bowmore, Mar 16 '15 at 13:14
Check the example in the javadoc of FileVisitor: http://docs.oracle.com/javase/7/docs/api/java/nio/file/FileVisitor.html — assylias, Mar 16 '15 at 13:27
What about this [org.apache.commons.io.FileUtils.copyDirectory(File, File)](https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/FileUtils.html) ... it does the job safety ... :D — udoline, Jun 13 '19 at 07:31

Christian Schneider · Answer 1 · 2020-04-08T09:53:49.120

32

In this way the code looks a bit simpler

import static java.nio.file.StandardCopyOption.*;

public  void copyFolder(Path src, Path dest) throws IOException {
    try (Stream<Path> stream = Files.walk(src)) {
        stream.forEach(source -> copy(source, dest.resolve(src.relativize(source))));
    }
}

private void copy(Path source, Path dest) {
    try {
        Files.copy(source, dest, REPLACE_EXISTING);
    } catch (Exception e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}

edited Apr 08 '20 at 09:53

answered May 18 '18 at 19:27

Christian Schneider

19,420
2
39
64

This looks like it won't handle sub folders – user1133275 Nov 14 '18 at 18:14
2

It does copy sub folders and their contents. – Romano Feb 14 '20 at 19:30
Recursive does work here though, needs following line before walk to ensure destination parent directories exists: `Files.createDirectories(dest.getParent());` – Gladwin Burboz Mar 09 '20 at 17:13
1

–1: stream is never closed. https://stackoverflow.com/a/60621544 is better. – Olivier Cailloux Apr 07 '20 at 00:01
1

What stream are you talking about? The solution does not use streams. – Christian Schneider Apr 07 '20 at 10:58
1

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/file/Files.html#walk(java.nio.file.Path,java.nio.file.FileVisitOption...) – Olivier Cailloux Apr 07 '20 at 18:18
1

I removed the −1 (but I still prefer [this](https://stackoverflow.com/a/60621544/859604) answer, for the reasons stated there). – Olivier Cailloux Apr 08 '20 at 22:32
With the added try my code looses some of its appeal :-) So I think the main difference is if you pack more than one line into a closure. I think it is just a personal style preference of me. – Christian Schneider Apr 09 '20 at 09:12

score 27 · Answer 2 · edited Dec 08 '22 at 21:25

Using Files.walkFileTree:

you don't need to worry about closing Streams.
(some other answers here forget that while using Files.walk)
handles IOException elegantly.
(Some other answers here would become more difficult when adding proper exception handling instead of a simple printStackTrace)

    public void copyFolder(Path source, Path target, CopyOption... options)
            throws IOException {
        Files.walkFileTree(source, new SimpleFileVisitor<Path>() {

            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
                    throws IOException {
                Files.createDirectories(target.resolve(source.relativize(dir).toString()));
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                    throws IOException {
                Files.copy(file, target.resolve(source.relativize(file).toString()), options);
                return FileVisitResult.CONTINUE;
            }
        });
    }

What this does is

walk recursively over all files in the directory.
When a directory is encountered (preVisitDirectory):
create the corresponding one in the target directory.
When a regular file is encountered (visitFile):
copy it.

options can be used to tailor the copy to your needs. For example to overwrite existing files in the target directory, use copyFolder(source, target, StandardCopyOption.REPLACE_EXISTING);

Much better than many other answers, for the reasons stated. One drawback that should be mentioned: when a security manager prevents access to some file, the copy of the files which cannot be accessed will silently fail. (This should be rare however, usually no security manager is used.) — Olivier Cailloux, Apr 07 '20 at 00:04
This solution is ok if there are no symbolic links, otherwise, it will copy they target dir and turn the link into an empty directory with the link name. — Chris Wolf, Jun 02 '20 at 21:18
If you want to follow symbolic links, you can replace [`Files.walkFileTree(source, visitor)`](https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#walkFileTree-java.nio.file.Path-java.nio.file.FileVisitor-) with [`Files.walkFileTree(source, EnumSet.of(FOLLOW_LINKS), Integer.MAX_VALUE, visitor)`](https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#walkFileTree-java.nio.file.Path-java.util.Set-int-java.nio.file.FileVisitor-) — neXus, Jun 05 '20 at 09:22

Mohit Kanwar · Answer 3 · 2020-04-08T05:29:48.463

16

How about the following code

public void copyFolder(File src, File dest) throws IOException {
        try (Stream<Path> stream = Files.walk(src.toPath())) {
            stream.forEachOrdered(sourcePath -> {

                try {
                    Files.copy(
                            /*Source Path*/
                            sourcePath,
                            /*Destination Path */
                            src.toPath().resolve(dest.toPath().relativize(sourcePath)));
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            });
        }
    }

edited Apr 08 '20 at 05:29

answered Dec 13 '15 at 17:35

Mohit Kanwar

2,962
7
39
59

4

Determining the target path can more elegantly be dine using Path API : `Path target = targetDir.resolve(sourceDir.relativize(path))` – bowmore Apr 25 '17 at 13:38
Hello Carl, How does order matters in copying files? I guess forEach should have been sufficient. – Mohit Kanwar Jan 11 '19 at 08:03
2

Please do not catch Exception and printStackTrace. Wrapping the IOException into an UncheckedIOException would be appropriate. – Olivier Cailloux Apr 07 '20 at 00:03
@OlivierCailloux yes, that is more apt. – Mohit Kanwar Apr 08 '20 at 05:31

score 10 · Answer 4 · edited Aug 27 '18 at 15:15

This version uses Files.walk and Path parameters as Java 8 suggests.

public static void copyFolder(Path src, Path dest) {
    try {
        Files.walk( src ).forEach( s -> {
            try {
                Path d = dest.resolve( src.relativize(s) );
                if( Files.isDirectory( s ) ) {
                    if( !Files.exists( d ) )
                        Files.createDirectory( d );
                    return;
                }
                Files.copy( s, d );// use flag to override existing
            } catch( Exception e ) {
                e.printStackTrace();
            }
        });
    } catch( Exception ex ) {
        ex.printStackTrace();
    }
}

score 1 · Answer 5 · answered Apr 23 '15 at 09:19

and one more version:

static void copyFolder(File src, File dest){
    // checks
    if(src==null || dest==null)
        return;
    if(!src.isDirectory())
        return;
    if(dest.exists()){
        if(!dest.isDirectory()){
            //System.out.println("destination not a folder " + dest);
            return;
        }
    } else {
        dest.mkdir();
    }

    if(src.listFiles()==null || src.listFiles().length==0)
        return;

    String strAbsPathSrc = src.getAbsolutePath();
    String strAbsPathDest = dest.getAbsolutePath();

    try {
        Files.walkFileTree(src.toPath(), new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file,
                    BasicFileAttributes attrs) throws IOException {
                File dstFile = new File(strAbsPathDest + file.toAbsolutePath().toString().substring(strAbsPathSrc.length()));
                if(dstFile.exists())
                    return FileVisitResult.CONTINUE;

                if(!dstFile.getParentFile().exists())
                    dstFile.getParentFile().mkdirs();

                //System.out.println(file + " " + dstFile.getAbsolutePath());
                Files.copy(file, dstFile.toPath());

                return FileVisitResult.CONTINUE;
            }
        });

    } catch (IOException e) {
        //e.printStackTrace();
        return;
    }

    return;
}

its code use java8 Files.walkFileTree function.

pwipo · Answer 6 · 2020-02-18T07:33:18.550

0

my version:

static private void copyFolder(File src, File dest) {
    // checks
    if(src==null || dest==null)
        return;
    if(!src.isDirectory())
        return;
    if(dest.exists()){
        if(!dest.isDirectory()){
            //System.out.println("destination not a folder " + dest);
            return;
        }
    } else {
        dest.mkdir();
    }

    File[] files = src.listFiles();
    if(files==null || files.length==0)
        return;

    for(File file: files){
        File fileDest = new File(dest, file.getName());
        //System.out.println(fileDest.getAbsolutePath());
        if(file.isDirectory()){
            copyFolder(file, fileDest);
        }else{
            if(fileDest.exists())
                continue;

            try {
                Files.copy(file.toPath(), fileDest.toPath());
            } catch (IOException e) {
                //e.printStackTrace();
            }
        }
    }
}

edited Feb 18 '20 at 07:33

answered Apr 22 '15 at 14:42

pwipo

463
3
7

1

Please consider adding some explanation about the code. – LittlePanda Apr 22 '15 at 14:44
I add some expensive checks. its usefull if no checks in external code, example - raw data from users. – pwipo Apr 22 '15 at 14:52
@pwipo I just wanted to thank you for this code, most of the examples I have found do not work but this works perfectly, you have saved me a lot of time by automating this, thank you!! – Tom Jun 14 '17 at 02:15
Really? Are you going to call listFiles() on the same object multiple times??? – Blake McBride Feb 16 '20 at 21:55
Correct me if I'm mistaken @blake-mcbride but I don't see how he is calling listFiles() on the same object? It's outside of the for loop and is only called again for recursion in a lower directory... – JohnRDOrazio Nov 02 '20 at 20:02
Clearly, it's not being called multiple times now.... (My comment was made 2/16. It was modified two days later..... – Blake McBride Nov 03 '20 at 21:58

score -1 · Answer 7 · answered Aug 05 '21 at 16:56

Can be used to copy source (file or directory) to target (directory)

void copy(Path source, Path target, boolean override) throws IOException {
    Path target = target.resolve(source.toFile().getName());
    Files.walkFileTree(source, new FileVisitor<Path>() {
        @Override
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
            Path targetDir = target.resolve(source.relativize(dir));
            if(Files.notExists(targetDir)) {
                Files.createDirectory(targetDir);
            }
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            Files.copy(file, target.resolve(source.relativize(file))));
            return FileVisitResult.CONTINUE;
        }

        @Override
        public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
            throw new RuntimeException("Copying file " + file + " failed", exc);
            // Consider looking at FileVisitResult options... 
        }

        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
            if (exc != null) {
                // TODO...
            }
            return FileVisitResult.CONTINUE; // Or whatever works for you
        }
    });
}

Java 8: Copy directory recursively?

7 Answers7

Linked