Copy Data from One File to Another in Java

Java provides a robust set of libraries for file operations, making it relatively simple to perform tasks like copying data from one file to another. This process is essential in various scenarios, such as data backup, log file processing, and more. In this article, we'll guide you through the steps to copy data from one file to another using Java.

Before diving into the code, let's understand the basic steps involved in copying data from one file to another:

Open the source file: You need to specify the file from which you want to read data.
Open the target file: This is where you'll write the data.
Read data from the source file: Read the content of the source file.
Write data to the target file: Write the content you read to the target file.
Close both files: Always remember to close the files after you're done.

Opening Files for Reading and Writing

Java provides several classes for file operations. For this task, we'll primarily use FileInputStream for reading and FileOutputStream for writing.

// Open the source file for reading
FileInputStream sourceFile = new FileInputStream("source.txt");
// Open the target file for writing
FileOutputStream targetFile = new FileOutputStream("target.txt");

Reading and Writing Data

To copy data from the source file to the target file, we'll read a chunk of data from the source and write it to the target until there's no more data to read.

// Define a buffer to hold the data
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = sourceFile.read(buffer)) != -1) {
    targetFile.write(buffer, 0, bytesRead);
}

Handling Exceptions

File operations can throw exceptions, so it's important to handle them properly. We'll use a try-catch block to handle any potential exceptions.

try {
    // File operations here
} catch (IOException e) {
    e.printStackTrace();
} finally {
    // Close the files
}
Closing Files
Always remember to close the files after you're done with them to free up system resources.
try {
    // File operations here
} catch (IOException e) {
    e.printStackTrace();
} finally {
    // Close the files
    sourceFile.close();
    targetFile.close();
}

Putting it All Together

Here's the complete code to copy data from one file to another:

import java.io.*;
public class FileCopy {
    public static void main(String[] args) {
        try {
            FileInputStream sourceFile = new FileInputStream("source.txt");
            FileOutputStream targetFile = new FileOutputStream("target.txt");
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = sourceFile.read(buffer)) != -1) {
                targetFile.write(buffer, 0, bytesRead);
            }
            sourceFile.close();
            targetFile.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Understanding File Streams

In Java, file operations are typically performed using streams. A stream is a sequence of data elements that are made available over time. It can be used to read data from a source (input stream) or write data to a destination (output stream).

Input Stream: Used for reading binary or text data from a source, such as a file. In this guide, we'll use FileInputStream for reading.

Output Stream: Used for writing binary or text data to a destination, such as a file. In this guide, we'll use FileOutputStream for writing.

Error Handling and File Existence Check

Before attempting to copy, it's wise to check if the source file actually exists. Also, ensure the target directory exists and, if not, create it.

File source = new File("source.txt");
File target = new File("target.txt");
if (!source.exists()) {
    System.out.println("Source file does not exist.");
    return;
}
File parentDirectory = target.getParentFile();
if (!parentDirectory.exists() && !parentDirectory.mkdirs()) {
    System.out.println("Could not create target directory.");
    return;
}

Buffered Streams for Efficiency

You can improve the performance of your file operations by using buffered streams. These classes provide buffering of the data to be read or written, which can greatly speed up the process.

BufferedInputStream sourceFile = new BufferedInputStream(new FileInputStream("source.txt"));
BufferedOutputStream targetFile = new BufferedOutputStream(new FileOutputStream("target.txt"));

FileCopy.java

import java.io.*;
public class FileCopy {
    public static void main(String[] args) {
        try {
            // User input for file names
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("Enter source file name: ");
            String sourceFileName = reader.readLine();
            System.out.print("Enter target file name: ");
            String targetFileName = reader.readLine();
            // Opening files
            FileInputStream sourceFile = new FileInputStream(sourceFileName);
            FileOutputStream targetFile = new FileOutputStream(targetFileName);
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = sourceFile.read(buffer)) != -1) {
                targetFile.write(buffer, 0, bytesRead);
            }
            // Closing files
            sourceFile.close();
            targetFile.close();
            System.out.println("Done writing.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

Enter source file name: source.txt
Enter target file name: target.txt
Done writing

Sourcefile:

Copy Data from One File to Another in Java

Targetfile:

Copying data from one file to another is a common operation in many applications. With Java's built-in file handling capabilities, it's a straightforward task. Remember to handle exceptions properly and close files after you're done with them to ensure efficient resource management.

Next TopicDead Code in Java

← prev next →