# Daily Hack #day66 - Fast File Copy using Java NIO

Java NIO (New Input/Output) provides a powerful set of APIs to handle file operations efficiently. For fast file copying, we can use the `FileChannel` class which is part of the NIO package. The `FileChannel` class allows for high-performance file operations, including transferring data between channels directly.

Here's an example of how to perform fast file copying using Java NIO:

### Fast File Copy using Java NIO

```java
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.channels.FileChannel;
import java.nio.file.StandardOpenOption;

public class FastFileCopy {

    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Usage: FastFileCopy <source file> <destination file>");
            return;
        }

        Path sourcePath = Paths.get(args[0]);
        Path destinationPath = Paths.get(args[1]);

        try {
            copyFileUsingFileChannel(sourcePath, destinationPath);
            System.out.println("File copied successfully.");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Failed to copy the file.");
        }
    }

    private static void copyFileUsingFileChannel(Path source, Path destination) throws IOException {
        // Create parent directories if they do not exist
        if (Files.notExists(destination.getParent())) {
            Files.createDirectories(destination.getParent());
        }

        try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ);
             FileChannel destinationChannel = FileChannel.open(destination, StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
            
            // Transfer data from source to destination
            long position = 0;
            long size = sourceChannel.size();
            while (position < size) {
                long transferred = sourceChannel.transferTo(position, size - position, destinationChannel);
                position += transferred;
            }
        }
    }
}
```

### Explanation

1. **Imports**: We import necessary classes from `java.nio.file` and `java.nio.channels`.
    
2. **Main Method**:
    
    * We check if the user provided both source and destination file paths.
        
    * We convert the provided file paths to `Path` objects.
        
3. **copyFileUsingFileChannel Method**:
    
    * **Create Parent Directories**: If the destination's parent directories do not exist, we create them using `Files.createDirectories()`.
        
    * **File Channels**: We open a `FileChannel` for the source file in read mode and another for the destination file in write mode. The `StandardOpenOption.CREATE` option is used to create the destination file if it does not exist.
        
    * **Transfer Data**: We use the `transferTo` method of `FileChannel` to transfer data from the source to the destination channel. This method is efficient as it can take advantage of low-level system operations.
        
4. **Exception Handling**: Proper exception handling ensures that any I/O errors during the file operations are caught and reported.
    

### Usage

Compile and run the program with the source and destination file paths as arguments:

```sh
javac FastFileCopy.java
java FastFileCopy sourceFilePath destinationFilePath
```

Replace `sourceFilePath` and `destinationFilePath` with the actual paths of the files you want to copy.

This approach ensures a fast and efficient file copy operation using Java NIO's `FileChannel`.