Copy a file

In JDK 7+, copying a file is a simple operation, involving a single call to File.copy.

Example


import java.io.IOException;
import java.nio.file.CopyOption;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

/** JDK 7+. */
public final class CopyFilesNew {
  
  public static void main(String... aArgs) throws IOException {
    Path FROM = Paths.get("C:\\Temp\\from.txt");
    Path TO = Paths.get("C:\\Temp\\to.txt");
    //overwrite existing file, if exists
    CopyOption[] options = new CopyOption[]{
      StandardCopyOption.REPLACE_EXISTING,
      StandardCopyOption.COPY_ATTRIBUTES
    }; 
    Files.copy(FROM, TO, options);
  }
} 

In older JDKs, however, copying a file involves a lot more code. It can be done either with FileChannels or with basic streams. The FileChannel technique is usually faster.

Here's an example showing both techniques.


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.channels.FileChannel;

/** 
 Copy files, using two techniques, FileChannels and streams.
 Using FileChannels is usually faster than using streams.
 JDK 6-.
*/
public final class CopyFiles {
  
  /* Change these settings before running this class. */
  
  /** The file to be copied. */
  public static final String INPUT_FILE = "C:\\TEMP\\cottage.jpg";
  
  /**
   The name of the copy to be created by this class.  
   If this file doesn't exist, it will be created, along with any 
   needed parent directories.  
  */
  public static final String COPY_FILE_TO = "C:\\TEMP10\\cottage_2.jpg";
  
  /** Run the example. */
  public static void main(String... aArgs) throws IOException{
    File source = new File(INPUT_FILE);
    File target = new File(COPY_FILE_TO);
    CopyFiles test = new CopyFiles();
    test.copyWithChannels(source, target, false);
    //test.copyWithStreams(source, target, false);
    log("Done.");
  }

  /** This may fail for VERY large files. */
  private void copyWithChannels(File aSourceFile, File aTargetFile, boolean aAppend) {
    log("Copying files with channels.");
    ensureTargetDirectoryExists(aTargetFile.getParentFile());
    FileChannel inChannel = null;
    FileChannel outChannel = null;
    FileInputStream inStream = null;
    FileOutputStream outStream = null;
    try{
      try {
        inStream = new FileInputStream(aSourceFile);
        inChannel = inStream.getChannel();
        outStream = new  FileOutputStream(aTargetFile, aAppend);        
        outChannel = outStream.getChannel();
        long bytesTransferred = 0;
        //defensive loop - there's usually only a single iteration :
        while(bytesTransferred < inChannel.size()){
          bytesTransferred += inChannel.transferTo(0, inChannel.size(), outChannel);
        }
      }
      finally {
        //being defensive about closing all channels and streams 
        if (inChannel != null) inChannel.close();
        if (outChannel != null) outChannel.close();
        if (inStream != null) inStream.close();
        if (outStream != null) outStream.close();
      }
    }
    catch (FileNotFoundException ex){
      log("File not found: " + ex);
    }
    catch (IOException ex){
      log(ex);
    }
  }
  
  private void copyWithStreams(File aSourceFile, File aTargetFile, boolean aAppend) {
    log("Copying files with streams.");
    ensureTargetDirectoryExists(aTargetFile.getParentFile());
    InputStream inStream = null;
    OutputStream outStream = null;
    try{
      try {
        byte[] bucket = new byte[32*1024];
        inStream = new BufferedInputStream(new FileInputStream(aSourceFile));
        outStream = new BufferedOutputStream(new FileOutputStream(aTargetFile, aAppend));
        int bytesRead = 0;
        while(bytesRead != -1){
          bytesRead = inStream.read(bucket); //-1, 0, or more
          if(bytesRead > 0){
            outStream.write(bucket, 0, bytesRead);
          }
        }
      }
      finally {
        if (inStream != null) inStream.close();
        if (outStream != null) outStream.close();
      }
    }
    catch (FileNotFoundException ex){
      log("File not found: " + ex);
    }
    catch (IOException ex){
      log(ex);
    }
  }
  
  private void ensureTargetDirectoryExists(File aTargetDir){
    if(!aTargetDir.exists()){
      aTargetDir.mkdirs();
    }
  }
  
  private static void log(Object aThing){
    System.out.println(String.valueOf(aThing));
  }
} 


See Also :
Always close streams
Reading and writing binary files
Would you use this technique?
Yes   No   Undecided   
© 2014 Hirondelle Systems | Source Code | Contact | License | RSS
Individual code snippets can be used under this BSD license - Last updated on September 21, 2013.
Over 2,000,000 unique IPs last year - Built with WEB4J.
- In Memoriam : Bill Dirani -