Copy File in Java from one Location to Another

Java, with its robust and versatile features, provides several methods to copy files from one location to another. Whether you're dealing with local file systems or remote servers, Java's rich API makes file manipulation a straightforward task. In this comprehensive guide, we will explore various techniques and libraries for copying files in Java, discussing their strengths, use cases, and best practices.

1. Traditional File I/O Approach

The standard way to copy files in Java involves using the java.nio.file package, introduced in Java 7. The Files class provides a static method named copy, which simplifies the process.

FileCopyExample.java

import java.io.IOException;
import java.nio.file.*;
public class FileCopyExample {
    public static void main(String[] args) {
        Path source = Paths.get("C:\\Users\\Mamilla Manoj\\OneDrive\\Desktop\\javatpoint\\exmp.txt");
        Path destination = Paths.get("C:\\Users\\Mamilla Manoj\\OneDrive\\Desktop\\javatpoint\\exmp1.txt");
        try {
            Files.copy(source, destination, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("File copied successfully using traditional I/O.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

File copied successfully using traditional I/O.

Copy File in Java from one Location to Another

This method is suitable for copying small to moderately sized files. However, for large files or frequent operations, more efficient alternatives exist.

2. Buffered Streams for Enhanced Performance

For larger files, utilizing buffered streams can significantly improve the performance of file copying. By wrapping the InputStream and OutputStream with BufferedInputStream and BufferedOutputStream, respectively, you can optimize the data transfer.

BufferedStreamCopyExample.java

import java.io.*;
public class BufferedStreamCopyExample {
    public static void main(String[] args) {
        String sourcePath = "path/to/source/largefile.bin";
        String destinationPath = "path/to/destination/largefile.bin";
        try (
            InputStream inputStream = new BufferedInputStream(new FileInputStream(sourcePath));
            OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(destinationPath))
        ) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }
            System.out.println("File copied successfully using buffered streams.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

File copied successfully using buffered streams.

This approach minimizes the number of I/O operations and provides better performance for copying large files.

3. Java 7 and Beyond: Paths and Files API

With Java 7, the java.nio.file package was introduced, providing the Path and Files classes. Leveraging these classes, you can copy entire directories effortlessly.

DirectoryCopyExample.java

import java.io.IOException;
import java.nio.file.*;
public class DirectoryCopyExample {
    public static void main(String[] args) {
        Path sourceDir = Paths.get("path/to/source/directory");
        Path destinationDir = Paths.get("path/to/destination/directory");
        try {
            Files.walkFileTree(sourceDir, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    Path targetFile = destinationDir.resolve(sourceDir.relativize(file));
                    Files.copy(file, targetFile, StandardCopyOption.REPLACE_EXISTING);
                    return FileVisitResult.CONTINUE;
                }
                @Override
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                    Path targetDir = destinationDir.resolve(sourceDir.relativize(dir));
                    Files.createDirectories(targetDir);
                    return FileVisitResult.CONTINUE;
                }
            });
            System.out.println("Directory copied successfully using Paths and Files API.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

File copied successfully using Paths and Files API.

This code snippet recursively copies all files and subdirectories from the source directory to the destination directory.

4. Apache Commons IO Library

For those who prefer a more concise and expressive syntax, the Apache Commons IO library provides convenient utility methods. The FileUtils class offers a simple copyFile method.

CommonsIOCopyExample.java

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
public class CommonsIOCopyExample {
    public static void main(String[] args) {
        File sourceFile = new File("path/to/source/file.txt");
        File destinationFile = new File("path/to/destination/file.txt");
        try {
            FileUtils.copyFile(sourceFile, destinationFile);
            System.out.println("File copied successfully using Apache Commons IO.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

File copied successfully using Apache Commons IO.

Adding the Apache Commons IO library to your project simplifies file manipulation tasks and provides a high-level API for common operations.

Copying files in Java can be accomplished through various approaches, each catering to different scenarios and preferences. From the traditional I/O methods to the advanced features introduced in Java 7, 8, and beyond, developers have a plethora of options to choose from.

When working with small to moderately sized files, the traditional I/O and buffered streams suffice. However, for larger files or complex directory structures, utilizing the enhanced capabilities of Java's NIO.2 package, Apache Commons IO, or FileChannel can lead to more efficient and maintainable code.

Consider the specific requirements of your project and the nature of the files you are dealing with when selecting the appropriate method. By understanding the strengths and use cases of each approach, you can optimize file copying operations in your Java applications.

Next TopicCreating Templates in Java

← prev next →