Diferentes formas de copiar archivos en Java

Existen principalmente 3 formas de copiar archivos utilizando el lenguaje Java. Son como se indica a continuación:

1. Uso de File Stream (método Naive)
2. Uso de la clase FileChannel
3. Uso de la clase Archivos.

Nota: Hay muchos otros métodos como Apache Commons IO FileUtils, pero solo estamos discutiendo la copia de archivos usando clases Java.

Método 1: uso de File Stream (método Naive)

Este es un método ingenuo en el que estamos utilizando un flujo de entrada de archivos para obtener caracteres de entrada del primer archivo y un flujo de salida de archivos para escribir caracteres de salida en otro archivo. Esto es como ver un archivo y escribir en otro.

Ejemplo:

// Java Program to Copy file using File Stream
 
// Importing input output classes
import java.io.*;
 
// Main Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
        throws IOException
    {
 
        // Creating two stream
        // one input and other output
        FileInputStream fis = null;
        FileOutputStream fos = null;
 
        // Try block to check for exceptions
        try {
 
            // Initializing both the streams with
            // respective file directory on local machine
 
            // Custom directory path on local machine
            fis = new FileInputStream(
                "C:\\Users\\Dipak\\Desktop\\input.txt");
 
            // Custom directory path on local machine
            fos = new FileOutputStream(
                "C:\\Users\\Dipak\\Desktop\\output.txt");
 
            int c;
 
            // Condition check
            // Reading the input file till there is input
            // present
            while ((c = fis.read()) != -1) {
 
                // Writing to output file of the specified
                // directory
                fos.write(c);
            }
 
            // By now writing to the file has ended, so
 
            // Display message on the console
            System.out.println(
                "copied the file successfully");
        }
 
        // Optional finally keyword but is good practice to
        // empty the occupied space is recommended whenever
        // closing files,connections,streams
        finally {
 
            // Closing the streams
 
            if (fis != null) {
 
                // Closing the fileInputStream
                fis.close();
            }
            if (fos != null) {
 
                // Closing the fileOutputStream
                fos.close();
            }
        }
    }
}

 
Producción:  

copied the file successfully 

Para el programa anterior, necesitamos un archivo input.txt y un archivo output.txt. Inicialmente, ambos archivos de texto se ven así
 

Después de la ejecución exitosa del programa,
 

Método 2: usar la clase FileChannel 

Esta es una clase presente en java.nio , paquete de canales y se usa para escribir, modificar, leer archivos. Los objetos de esta clase crean un canal de archivos buscable a través del cual se realizan todas estas actividades. Esta clase básicamente proporciona dos métodos denominados de la siguiente manera:

• transferFrom(ReadableByteChannel src, posición larga, conteo largo): transfiere bytes al canal que llama a este método desde el canal src. Esto se llama por el canal de destino. La posición es el lugar de un puntero desde donde se iniciarán las acciones de copia. Count especifica el tamaño del archivo que es casi igual a la cantidad de contenido que contiene.
• transferTo(posición larga, conteo largo, destino WritableByteChannel) : transfiere bytes desde el canal de origen o de llamada al método al canal de destino del archivo. Este método se llama principalmente utilizando el canal de origen y Count menciona el tamaño del archivo de origen y la posición desde donde se realizará la copia.

Por lo tanto, podemos usar cualquiera de los dos métodos para transferir datos de archivos y copiarlos. 

Ejemplo:

// Java Program to Copy Files Using FileChannel Class
 
// Importing java.nio package for network linking
// Importing input output classes
import java.io.*;
import java.nio.channels.FileChannel;
 
// Main Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
        throws IOException
    {
 
        // Creating two channels one input and other output
        // by creating two objects of FileChannel Class
        FileChannel src
            = new FileInputStream(
                  "C:\\Users\\Dipak\\Desktop\\input.txt")
                  .getChannel();
        FileChannel dest
            = new FileOutputStream(
                  "C:\\Users\\Dipak\\Desktop\\output.txt")
                  .getChannel();
 
        // Try block to check for exceptions
        try {
 
            // Transferring files in one go from source to
            // destination using transferFrom() method
            dest.transferFrom(src, 0, src.size());
            // we can also use transferTo
            // src.transferTo(0,src.size(),dest);
        }
 
        // finally keyword is good practice to save space in
        // memory by closing files, connections, streams
        finally {
 
            // Closing the channels this makes the space
            // free
 
            // Closing the source channel
            src.close();
 
            // Closing the destination channel
            dest.close();
        }
    }
}

Producción: 

Para el programa anterior, necesitamos un archivo input.txt y un archivo output.txt. Inicialmente, ambos archivos de texto se ven así

Después de la ejecución exitosa del programa,

Método 3: Uso de la clase de archivos 

Esta es una clase presente en el paquete java.nio.File . Esta clase proporciona 3 métodos para copiar los archivos que son los siguientes:
 

• copy(InputStream in, Path target): copia todos los bytes de datos del flujo del archivo de entrada a la ruta de salida del archivo de salida. No se puede usar para hacer una copia de una parte específica en un archivo fuente. Aquí no estamos obligados a crear un archivo de salida. Se crea automáticamente durante la ejecución del código.
• copy(Origen de la ruta, OutputStream out): copia todos los bytes del archivo especificado en la fuente de la ruta al flujo de salida del archivo de salida.
• copy(Origen de la ruta, Destino de la ruta): Copia archivos utilizando la ruta de los archivos de origen y de destino. No es necesario crear el archivo de salida aquí también.

Ejemplo:

import java.nio.file.Files;
import java.io.*;
// save the file named as GFG.java
public class GFG{
   
    // main method
    public static void main(String[] args) throws IOException{
       
        // creating two channels
        // one input and other output   
        File src = new File("C:\\Users\\Dipak\\Desktop\\input.txt");
        File dest = new File("C:\\Users\\Dipak\\Desktop\\output.txt");
             
        // using copy(InputStream,Path Target); method
        Files.copy(src.toPath(), dest.toPath());
       
        // here we are not required to have an
        // output file at the specified target.
        // same way we can use other method also.
             
    }
}

Producción:

Para el programa anterior, necesitamos un archivo input.txt y un archivo output.txt. Inicialmente, ambos archivos de texto se ven así

Después de la ejecución exitosa del programa,

Nota: De todos estos métodos, el de transmisión es rápido en proceso, pero si alguien quiere ser técnico y más avanzado, puede optar por los otros dos métodos. Además, el método FileChannel nos brinda muchas opciones para controlar la parte del archivo que se copiará y especificar su tamaño.