Стандартный краткий способ скопировать файл в Java?

Меня всегда беспокоило, что единственный способ скопировать файл в Java - это открыть потоки, объявить буфер, прочитать один файл, пройти через него и записать его в другой поток. Сеть изобилует похожими, но все же немного отличающимися реализациями этого типа решения.

Есть ли лучший способ, который остается в пределах языка Java (то есть не подразумевает выполнение специфичных для ОС команд)? Возможно, в каком-нибудь надежном пакете утилит с открытым исходным кодом, который, по крайней мере, затмит эту базовую реализацию и предоставит однострочное решение?

Как упоминалось выше, Apache Commons IO - это путь, в частности FileUtils . copyFile () ; он берет на себя всю тяжелую работу за вас.

И, как постскриптум, обратите внимание, что в последних версиях FileUtils (таких как выпуск 2.0.1) добавлено использование NIO для копирования файлов; NIO может значительно повысить производительность копирования файлов , в значительной степени потому, что процедуры NIO откладывают копирование непосредственно в ОС / файловую систему, а не обрабатывают его, читая и записывая байты через уровень Java. Поэтому, если вы ищете производительность, возможно, стоит проверить, используете ли вы последнюю версию FileUtils.

Я бы избегал использования мега-API, как Apache Commons. Это упрощенная операция, встроенная в JDK в новом пакете NIO. Это было отчасти уже связано с предыдущим ответом, но ключевой метод в API NIO - это новые функции «TransferTo» и «TransferFrom».

http://java.sun.com/javase/6/docs/api/java/nio/channels/FileChannel.html#transferTo(long,%20long,%20java.nio.channels.WritableByteChannel)

Одна из связанных статей демонстрирует отличный способ интеграции этой функции в ваш код с помощью метода TransferFrom:

public static void copyFile(File sourceFile, File destFile) throws IOException {
    if(!destFile.exists()) {
        destFile.createNewFile();
    }

    FileChannel source = null;
    FileChannel destination = null;

    try {
        source = new FileInputStream(sourceFile).getChannel();
        destination = new FileOutputStream(destFile).getChannel();
        destination.transferFrom(source, 0, source.size());
    }
    finally {
        if(source != null) {
            source.close();
        }
        if(destination != null) {
            destination.close();
        }
    }
}

Изучение NIO может быть немного сложнее, так что вы можете просто поверить этому механику, прежде чем уйти и попытаться изучить NIO в одночасье. Из личного опыта очень трудно научиться, если у вас нет такого опыта и вы познакомились с IO через потоки java.io.

Теперь с Java 7 вы можете использовать следующий синтаксис try-with-resource:

public static void copyFile( File from, File to ) throws IOException {

    if ( !to.exists() ) { to.createNewFile(); }

    try (
        FileChannel in = new FileInputStream( from ).getChannel();
        FileChannel out = new FileOutputStream( to ).getChannel() ) {

        out.transferFrom( in, 0, in.size() );
    }
}

Или, что еще лучше, это также может быть достигнуто с помощью нового класса Files, представленного в Java 7:

public static void copyFile( File from, File to ) throws IOException {
    Files.copy( from.toPath(), to.toPath() );
}

Довольно шикарно, а?

• Эти методы предназначены для повышения производительности (они интегрируются с собственным вводом / выводом операционной системы).
• Эти методы работают с файлами, каталогами и ссылками.
• Каждый из представленных вариантов может быть опущен - они являются необязательными.

Сервисный класс

package com.yourcompany.nio;

class Files {

    static int copyRecursive(Path source, Path target, boolean prompt, CopyOptions options...) {
        CopyVisitor copyVisitor = new CopyVisitor(source, target, options).copy();
        EnumSet<FileVisitOption> fileVisitOpts;
        if (Arrays.toList(options).contains(java.nio.file.LinkOption.NOFOLLOW_LINKS) {
            fileVisitOpts = EnumSet.noneOf(FileVisitOption.class) 
        } else {
            fileVisitOpts = EnumSet.of(FileVisitOption.FOLLOW_LINKS);
        }
        Files.walkFileTree(source[i], fileVisitOpts, Integer.MAX_VALUE, copyVisitor);
    }

    private class CopyVisitor implements FileVisitor<Path>  {
        final Path source;
        final Path target;
        final CopyOptions[] options;

        CopyVisitor(Path source, Path target, CopyOptions options...) {
             this.source = source;  this.target = target;  this.options = options;
        };

        @Override
        FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        // before visiting entries in a directory we copy the directory
        // (okay if directory already exists).
        Path newdir = target.resolve(source.relativize(dir));
        try {
            Files.copy(dir, newdir, options);
        } catch (FileAlreadyExistsException x) {
            // ignore
        } catch (IOException x) {
            System.err.format("Unable to create: %s: %s%n", newdir, x);
            return SKIP_SUBTREE;
        }
        return CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        Path newfile= target.resolve(source.relativize(file));
        try {
            Files.copy(file, newfile, options);
        } catch (IOException x) {
            System.err.format("Unable to copy: %s: %s%n", source, x);
        }
        return CONTINUE;
    }

    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
        // fix up modification time of directory when done
        if (exc == null && Arrays.toList(options).contains(COPY_ATTRIBUTES)) {
            Path newdir = target.resolve(source.relativize(dir));
            try {
                FileTime time = Files.getLastModifiedTime(dir);
                Files.setLastModifiedTime(newdir, time);
            } catch (IOException x) {
                System.err.format("Unable to copy all attributes to: %s: %s%n", newdir, x);
            }
        }
        return CONTINUE;
    }

    @Override
    public FileVisitResult visitFileFailed(Path file, IOException exc) {
        if (exc instanceof FileSystemLoopException) {
            System.err.println("cycle detected: " + file);
        } else {
            System.err.format("Unable to copy: %s: %s%n", file, exc);
        }
        return CONTINUE;
    }
}

Копирование каталога или файла

long bytes = java.nio.file.Files.copy( 
                 new java.io.File("<filepath1>").toPath(), 
                 new java.io.File("<filepath2>").toPath(),
                 java.nio.file.StandardCopyOption.REPLACE_EXISTING,
                 java.nio.file.StandardCopyOption.COPY_ATTRIBUTES,
                 java.nio.file.LinkOption.NOFOLLOW_LINKS);

Перемещение каталога или файла

long bytes = java.nio.file.Files.move( 
                 new java.io.File("<filepath1>").toPath(), 
                 new java.io.File("<filepath2>").toPath(),
                 java.nio.file.StandardCopyOption.ATOMIC_MOVE,
                 java.nio.file.StandardCopyOption.REPLACE_EXISTING);

Копирование каталога или файла рекурсивно

long bytes = com.yourcompany.nio.Files.copyRecursive( 
                 new java.io.File("<filepath1>").toPath(), 
                 new java.io.File("<filepath2>").toPath(),
                 java.nio.file.StandardCopyOption.REPLACE_EXISTING,
                 java.nio.file.StandardCopyOption.COPY_ATTRIBUTES
                 java.nio.file.LinkOption.NOFOLLOW_LINKS );

В Java 7 это просто ...

File src = new File("original.txt");
File target = new File("copy.txt");

Files.copy(src.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING);

Чтобы скопировать файл и сохранить его по пути назначения, вы можете использовать метод ниже.

public void copy(File src, File dst) throws IOException {
    InputStream in = new FileInputStream(src);
    try {
        OutputStream out = new FileOutputStream(dst);
        try {
            // Transfer bytes from in to out
            byte[] buf = new byte[1024];
            int len;
            while ((len = in.read(buf)) > 0) {
                out.write(buf, 0, len);
            }
        } finally {
            out.close();
        }
    } finally {
        in.close();
    }
}

Обратите внимание, что все эти механизмы копируют только содержимое файла, а не метаданные, такие как разрешения. Таким образом, если вы скопируете или переместите исполняемый файл .sh в Linux, новый файл не будет исполняемым.

Чтобы действительно скопировать или переместить файл, то есть получить тот же результат, что и при копировании из командной строки, вам действительно нужно использовать собственный инструмент. Либо сценарий оболочки, либо JNI.

По-видимому, это может быть исправлено в Java 7 - http://today.java.net/pub/a/today/2008/07/03/jsr-203-new-file-apis.html . Скрещенные пальцы!

В библиотеке Google Guava также есть метод копирования :

общедоступная статическая пустая копия ( файл  из,
                         Файл  в)
                 бросает IOException

Копирует все байты из одного файла в другой.

Предупреждение: Если toпредставляет существующий файл, этот файл будет перезаписан содержимым from. Если toи fromобратиться к одному и тому же файлу, содержимое этого файла будет удалено.

Параметры:from - исходный файл to- файл назначения

Выдает: IOException - если возникает ошибка ввода-вывода IllegalArgumentException- еслиfrom.equals(to)

Доступно как стандарт в Java 7, path.copyTo: http://openjdk.java.net/projects/nio/javadoc/java/nio/file/Path.html http://java.sun.com/docs/books/ учебник / важно / ю / copy.html

Я не могу поверить, что им потребовалось так много времени, чтобы стандартизировать что-то такое простое и простое, как копирование файлов :(

Три возможные проблемы с приведенным выше кодом:

1. Если getChannel выдает исключение, вы можете пропустить открытый поток.
2. Для больших файлов вы можете пытаться передать больше, чем может обработать ОС.
3. Вы игнорируете возвращаемое значение TransferFrom, поэтому оно может копировать только часть файла.

Вот почему org.apache.tools.ant.util.ResourceUtils.copyResourceтак сложно. Также обратите внимание, что хотя TransferFrom в порядке, TransferTo ломается на JDK 1.4 в Linux (см. Идентификатор ошибки: 5056395 ) - Джесси Глик Ян

Если вы находитесь в веб-приложении, которое уже использует Spring, и если вы не хотите включать Apache Commons IO для простого копирования файлов, вы можете использовать FileCopyUtils среды Spring.

Вот три способа, которыми вы можете легко скопировать файлы с помощью одной строки кода!

Java7 :

java.nio.file.Files # копия

private static void copyFileUsingJava7Files(File source, File dest) throws IOException {
    Files.copy(source.toPath(), dest.toPath());
}

Appache Commons IO :

FileUtils # CopyFile

private static void copyFileUsingApacheCommonsIO(File source, File dest) throws IOException {
    FileUtils.copyFile(source, dest);
}

Гуава :

Файлы # копия

private static void copyFileUsingGuava(File source,File dest) throws IOException{
    Files.copy(source,dest);          
}

public static void copyFile(File src, File dst) throws IOException
{
    long p = 0, dp, size;
    FileChannel in = null, out = null;

    try
    {
        if (!dst.exists()) dst.createNewFile();

        in = new FileInputStream(src).getChannel();
        out = new FileOutputStream(dst).getChannel();
        size = in.size();

        while ((dp = out.transferFrom(in, p, size)) > 0)
        {
            p += dp;
        }
    }
    finally {
        try
        {
            if (out != null) out.close();
        }
        finally {
            if (in != null) in.close();
        }
    }
}

Копия NIO с буфером - самая быстрая в моем тесте. Посмотрите рабочий код ниже из моего тестового проекта на https://github.com/mhisoft/fastcopy

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.text.DecimalFormat;


public class test {

private static final int BUFFER = 4096*16;
static final DecimalFormat df = new DecimalFormat("#,###.##");
public static void nioBufferCopy(final File source, final File target )  {
    FileChannel in = null;
    FileChannel out = null;
    double  size=0;
    long overallT1 =  System.currentTimeMillis();

    try {
        in = new FileInputStream(source).getChannel();
        out = new FileOutputStream(target).getChannel();
        size = in.size();
        double size2InKB = size / 1024 ;
        ByteBuffer buffer = ByteBuffer.allocateDirect(BUFFER);

        while (in.read(buffer) != -1) {
            buffer.flip();

            while(buffer.hasRemaining()){
                out.write(buffer);
            }

            buffer.clear();
        }
        long overallT2 =  System.currentTimeMillis();
        System.out.println(String.format("Copied %s KB in %s millisecs", df.format(size2InKB),  (overallT2 - overallT1)));
    }
    catch (IOException e) {
        e.printStackTrace();
    }

    finally {
        close(in);
        close(out);
    }
}

private static void close(Closeable closable)  {
    if (closable != null) {
        try {
            closable.close();
        } catch (IOException e) {
            if (FastCopy.debug)
                e.printStackTrace();
        }    
    }
}

}

Быстро и работать со всеми версиями Java, а также Android:

private void copy(final File f1, final File f2) throws IOException {
    f2.createNewFile();

    final RandomAccessFile file1 = new RandomAccessFile(f1, "r");
    final RandomAccessFile file2 = new RandomAccessFile(f2, "rw");

    file2.getChannel().write(file1.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, f1.length()));

    file1.close();
    file2.close();
}

Немного опоздал на вечеринку, но вот сравнение времени, затрачиваемого на копирование файла с использованием различных методов копирования файлов. Я перебрал методы 10 раз и набрал среднее. Передача файлов с использованием потоков ввода-вывода кажется худшим кандидатом:

Вот методы:

private static long fileCopyUsingFileStreams(File fileToCopy, File newFile) throws IOException {
    FileInputStream input = new FileInputStream(fileToCopy);
    FileOutputStream output = new FileOutputStream(newFile);
    byte[] buf = new byte[1024];
    int bytesRead;
    long start = System.currentTimeMillis();
    while ((bytesRead = input.read(buf)) > 0)
    {
        output.write(buf, 0, bytesRead);
    }
    long end = System.currentTimeMillis();

    input.close();
    output.close();

    return (end-start);
}

private static long fileCopyUsingNIOChannelClass(File fileToCopy, File newFile) throws IOException
{
    FileInputStream inputStream = new FileInputStream(fileToCopy);
    FileChannel inChannel = inputStream.getChannel();

    FileOutputStream outputStream = new FileOutputStream(newFile);
    FileChannel outChannel = outputStream.getChannel();

    long start = System.currentTimeMillis();
    inChannel.transferTo(0, fileToCopy.length(), outChannel);
    long end = System.currentTimeMillis();

    inputStream.close();
    outputStream.close();

    return (end-start);
}

private static long fileCopyUsingApacheCommons(File fileToCopy, File newFile) throws IOException
{
    long start = System.currentTimeMillis();
    FileUtils.copyFile(fileToCopy, newFile);
    long end = System.currentTimeMillis();
    return (end-start);
}

private static long fileCopyUsingNIOFilesClass(File fileToCopy, File newFile) throws IOException
{
    Path source = Paths.get(fileToCopy.getPath());
    Path destination = Paths.get(newFile.getPath());
    long start = System.currentTimeMillis();
    Files.copy(source, destination, StandardCopyOption.REPLACE_EXISTING);
    long end = System.currentTimeMillis();

    return (end-start);
}

Единственный недостаток, который я вижу при использовании класса канала NIO, это то, что я все еще не могу найти способ показать промежуточный процесс копирования файла.