¿Manera concisa estándar para copiar un archivo en Java?

Siempre me ha molestado que la única forma de copiar un archivo en Java sea abrir flujos, declarar un búfer, leer un archivo, recorrerlo y escribirlo en el otro. La web está llena de implementaciones similares, aunque todavía ligeramente diferentes, de este tipo de solución.

¿Hay una mejor manera de permanecer dentro de los límites del lenguaje Java (lo que significa que no implica ejecutar comandos específicos del sistema operativo)? ¿Quizás en algún paquete de utilidad de código abierto confiable, que al menos oscurezca esta implementación subyacente y proporcione una solución de una sola línea?

 rob17 jun. 2013 23:54
Si usa Java 7, use Files.copy en su lugar, como lo recomienda @GlenBest:stackoverflow.com/a/16600787/44737
 toolkit20 sept. 2008 04:04
Podría haber algo en Apache CommonsFileUtils, Concretamente, lacopiar archivo metodos

Respuestas a la pregunta(16)

http://openjdk.java.net/projects/nio/javadoc/java/nio/file/Path.html http://java.sun.com/docs/books/tutorial/essential/io/copy.html

No puedo creer que les tomó tanto tiempo estandarizar algo tan común y simple como la copia de archivos :(

 Jesse Glick03 mar. 2012 01:59
No hay Path.copyTo; es Files.copy.
 samuel owino15 jun. 2017 15:25
Tu enlace es 404 hombre.
Solución de preguntas

Apache Commons IO es el camino a seguir, específicamenteFileUtils.copiar archivo(); se encarga de todo el trabajo pesado para usted.

Y como posdata, tenga en cuenta que las versiones recientes de FileUtils (como la versión 2.0.1) han agregado el uso de NIO para copiar archivos;NIO puede aumentar significativamente el rendimiento de copia de archivos, en gran parte debido a que las rutinas NIO aplazan la copia directamente al sistema operativo / sistema de archivos en lugar de manejarla leyendo y escribiendo bytes a través de la capa Java. Por lo tanto, si está buscando rendimiento, podría valer la pena comprobar que está utilizando una versión reciente de FileUtils.

 drye01 oct. 2008 14:47
Esto también es muy rápido, reemplacé una sección de código que estábamos ejecutando xCopy para copiar algunos directorios y ha aumentado la velocidad muy bien. (Yo usé la versión del repositorio)
 delfuego21 sept. 2008 04:04
No tengo ni idea ... He rastreado todas las fuentes de información pública que puedo encontrar, y no hay ninguna mención de una posible fecha de lanzamiento. Sin embargo, el sitio de JIRA muestra solo cinco temas abiertos, ¿quizás pronto?
 Peter03 sept. 2009 01:05
Lanzamiento público de Apache Commons IO aún en 1.4, grrrrrrr
 IlDan06 feb. 2012 11:46
Una advertencia para la gente de Android: esto NO está incluido en las API estándar de Android
 Peter20 sept. 2008 05:01
Muy útil: ¿tiene alguna idea de cuándo un lanzamiento oficial incorporará estos cambios nio?
 Simon Nickerson08 abr. 2011 12:08
A partir de diciembre de 2010, Apache Commons IO se encuentra en 2.0.1, que tiene la funcionalidad NIO. Respuesta actualizada.
 rob17 jun. 2013 23:57
Si usa Java 7 o más reciente, puede usar Files.copy como lo sugiere @GlenBest:stackoverflow.com/a/16600787/44737
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();
        }
    }
}
 Rup16 ene. 2014 12:41
Entonces, ¿la diferencia con la respuesta principal aceptada es que tienes la transferencia desde un bucle while?
 user20742119 jul. 2014 11:43
Ni siquiera compila, y la llamada a createNewFile () es redundante y desperdiciadora.

pero aquí hay una comparación del tiempo que se tarda en copiar un archivo utilizando varios métodos de copia de archivos. Hice un bucle a través de los métodos por 10 veces y tomé un promedio. La transferencia de archivos utilizando flujos de IO parece ser el peor candidato:

Aquí están los métodos:

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);
}

El único inconveniente que puedo ver al usar la clase de canal NIO es que todavía no puedo encontrar una manera de mostrar el progreso de la copia intermedia de archivos.

método de copia:

public static void copy(File from,
                        File to)
                 throws IOException
Copia todos los bytes de un archivo a otro.

Advertencia: Sito representa un archivo existente, ese archivo se sobrescribirá con el contenido defrom. Sito yfrom referirse amismo archivo, el contenido de ese archivo será eliminado.

Parámetros:from - el archivo fuenteto - el archivo de destino

Tiros <a href="http://download.oracle.com/javase/6/docs/api/java/io/IOException.html?is-external=true" rel="nofollow noreferrer" title="class or interface in java.io">IOException</a> - si se produce un error de E / S<a href="http://download.oracle.com/javase/6/docs/api/java/lang/IllegalArgumentException.html?is-external=true" rel="nofollow noreferrer" title="class or interface in java.lang">IllegalArgumentException</a> - Sifrom.equals(to)

Si getChannel lanza una excepción, puede filtrar una secuencia abierta.Para archivos grandes, es posible que esté intentando transferir más de una vez de lo que el sistema operativo puede manejar.Está ignorando el valor de retorno de transferFrom, por lo que podría estar copiando solo una parte del archivo.

Esta es la razón pororg.apache.tools.ant.util.ResourceUtils.copyResource es tan complicado También tenga en cuenta que si bien transferFrom está bien, transferTo rompe en JDK 1.4 en Linux (consulteID de error: 5056395) - Jesse Glick Jan

igo de trabajo a continuación de un proyecto de prueba mío enhttps://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();
        }    
    }
}

}

 aswzen13 oct. 2016 06:44
¡agradable! Esta es más rápida que la transmisión java.io estándar. Copia 10 GB solo en 160 segundos

sola línea de código!

Java7:

java.nio.file.Files # copy

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);
}

Guayaba :

Archivos # copia

private static void copyFileUsingGuava(File source,File dest) throws IOException{
    Files.copy(source,dest);          
}
 Pimp Trizkit16 feb. 2016 22:18
El primero necesita 3 parámetros.Files.copy usando solo 2 parametros es paraPath aStream. Solo agrega el parámetroStandardCopyOption.COPY_ATTRIBUTES oStandardCopyOption.REPLACE_EXISTING paraPath aPath
 momomo17 ene. 2015 11:07
El primero no funciona para directorios. Maldita sea, todos se están equivocando. Más de una comunicación de la API es tu culpa. Yo también lo entendí mal.
Estos métodos están diseñados para el rendimiento (se integran con el sistema operativo I / O nativo).Estos métodos funcionan con archivos, directorios y enlaces.Cada una de las opciones suministradas puede quedar fuera, son opcionales.La clase de utilidad
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;
    }
}
Copiando un directorio o archivo
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);
Mover un directorio o archivo
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);
Copiando un directorio o archivo recursivamente
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 );
 Stuart Rossiter03 dic. 2014 14:15
El nombre del paquete para Archivos fue incorrecto (debe ser java.nio.file no java.nio). He enviado una edición para eso; Espero que esté bien!

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();
}
 Rup14 nov. 2013 11:48
Sin embargo, no todos los sistemas de archivos admiten archivos asignados en memoria, y creo que es relativamente caro para archivos pequeños.
 user20742119 jul. 2014 11:44
No funciona con ninguna versión de Java anterior a la 1.4, y no hay nada que garantice que una sola escritura sea suficiente.

En Java 7 es fácil ...

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

Files.copy(src.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING);
 Uri Agassi20 jun. 2014 21:59
¿Qué agrega tu respuesta a la de Scott o Glen?
 Kevin Sadler21 jun. 2014 10:18
Es conciso, menos es más. Sus respuestas son buenas y detalladas, pero las extrañé al mirarlas. Desafortunadamente, hay muchas respuestas a esto y muchas de ellas son largas, obsoletas y complicadas, y las buenas respuestas de Scott y Glen se perdieron en eso (daré votos para ayudar con eso). Me pregunto si mi respuesta podría mejorarse reduciéndola a tres líneas eliminando la existencia () y el mensaje de error.
 Kevin Sadler21 ene. 2015 13:01
@momo la pregunta era cómo copiar un archivo.
 momomo17 ene. 2015 11:06
Esto no funciona para los directorios. Maldita sea, todos se están equivocando. Más de una comunicación de la API es su culpa. Yo también lo entendí mal.

l archivo, no los metadatos, como los permisos. Entonces, si tuviera que copiar o mover un archivo .sh ejecutable en linux, el nuevo archivo no sería ejecutable.

Para realmente copiar o mover un archivo, es decir, para obtener el mismo resultado que al copiar desde una línea de comando, realmente necesita usar una herramienta nativa. Ya sea un script de shell o JNI.

Aparentemente, esto podría ser arreglado en java 7 -http://today.java.net/pub/a/today/2008/07/03/jsr-203-new-file-apis.html. ¡Dedos cruzados!

puedes usar la siguiente sintaxis de prueba de recursos:

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() );
    }
}

O, mejor aún, esto también se puede lograr usando la nueva clase de Archivos introducida en Java 7:

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

Bastante elegante, ¿eh?

 Rick Hodgin19 oct. 2011 00:30
Es increíble que Java no haya agregado cosas como esta antes de hoy. Ciertas operaciones son simplemente lo esencial de la escritura de software de computadora. Los desarrolladores de Oracle de Java podrían aprender una o dos cosas de los sistemas operativos, observando qué servicios ofrecen, para que sea MÁS FÁCIL que los novatos puedan migrar.
 ChrisCantrell27 nov. 2012 01:26
¡Ah gracias! No estaba al tanto de la nueva clase de "Archivos" con todas sus funciones auxiliares. Tiene exactamente lo que necesito. Gracias por el ejemplo.
 rob18 jun. 2013 19:13
@Scott: Pete pidió una solución de una línea y está tan cerca ... no es necesario envolver Files.copy en un método copyFile. Acabo de poner Files.copy (Path from, Path to) al principio de su respuesta y menciono que puede usar File.toPath () si tiene objetos File existentes: Files.copy (fromFile.toPath (), toFile.toPath ())
 Pankaj04 dic. 2012 01:36
En cuanto al rendimiento, Java NIO FileChannel es mejor, lea este artículojournaldev.com/861/4-ways-to-copy-file-in-java
 user20742101 jun. 2013 03:30
Este código tiene unamayor problema. transferTo () debe llamarse en un bucle. No garantiza transferir la totalidad del importe solicitado.

puede utilizar el siguiente método.

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();
    }
}
 James Wierzba16 abr. 2015 21:36
Trabajado como un encanto. La mejor solución que no requiere bibliotecas de terceros y funciona en java 1.6. Gracias.
 Solomonoff's Secret07 sept. 2018 18:55
Este código es incorrecto.InputStream.read Puede devolver 0 incluso si hay más datos.InputStream.read Devuelve -1 cuando no hay más datos. Así que el bucle debería terminar cuando devuelve -1, no 0.
 Rup19 jul. 2014 12:02
@EJP OK, pero no es muy inteligente. La copia de archivos debe ser una operación del sistema operativo o del sistema de archivos, no una operación de la aplicación: es de esperar que Java pueda detectar una copia y convertirla en una operación del sistema operativo, excepto al leer explícitamente el archivo. Si no cree que Java pueda hacer eso, ¿confiaría en él para optimizar las lecturas de 1K y escribir en bloques más grandes? Y si la fuente y el destino se encontraban en un recurso compartido remoto a través de una red lenta, esto claramente está haciendo un trabajo innecesario. Sí, algunos JAR de terceros son estúpidamente grandes (¡Guayaba!) Pero agregan muchas cosas como esta hechas correctamente.
 Rup18 may. 2015 10:59
@EJP Por "correcto" quise decir 1) usando las mejores API disponibles, por ejemplo. donde sea posible, las nuevas IO 2) presentando las llamadas a Java de manera que pueda reconocer fácilmente que se trata de una copia de archivo, por ejemplo, canales que representan archivos completos para leer y escribir, como en otras respuestas aquí, y convertirlos en una sola llamada del sistema operativo. Creo que este enfoque es tan lento como es probable que obtengas, especialmente con un pequeño búfer.
 user20742117 may. 2015 20:01
@Rup. Estoy de acuerdo en que debería ser una función del sistema operativo, pero no puedo hacer que tu comentario tenga ningún otro sentido. La parte después de los primeros dos puntos carece de un verbo en alguna parte; Yo tampoco 'confiaría' en que Java no convierta los bloques 1k en algo más grande, aunque yo mismo usaría bloques mucho más grandes; Nunca escribiría una aplicación que usara archivos compartidos en primer lugar; y no estoy al tanto de que cualquier biblioteca de terceros haga algo más "apropiado" (sea lo que sea lo que quieras decir) que este código, excepto probablemente para usar un búfer más grande.
 John Henckel29 oct. 2013 21:52
Funciona con Java 6, sin tarros extra.
 Rup23 oct. 2013 16:18
Esto funcionará, pero no creo que sea mejor que las otras respuestas aquí.
 user20742119 jul. 2014 11:41
@Rup Es considerablemente mejor que las otras respuestas aquí, (a)porque funciona, y (b) porque no se basa en software de terceros.

ache Commons IO para copiar archivos de manera simple, puede usarFileCopyUtils del marco de primavera.

a operación simplista y está integrada en el JDK en el nuevo paquete NIO. Ya estaba vinculado en una respuesta anterior, pero el método clave en la API de NIO son las nuevas funciones "transferTo" y "transferFrom".

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

Uno de los artículos vinculados muestra una gran manera de cómo integrar esta función en su código, usando la transferencia desde:

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();
        }
    }
}

Aprender a NIO puede ser un poco complicado, por lo que es posible que desee simplemente confiar en esta mecánica antes de ir y tratar de aprender NIO de la noche a la mañana Desde la experiencia personal, puede ser muy difícil de aprender si no tiene la experiencia y fue introducido a IO a través de las transmisiones java.io.

 foz26 ago. 2014 13:39
En Windows Server, encuentro que los archivos copiados así con NIO de forma intermitente no pueden ser renombrados ni eliminados, incluso después de llamar a close () en todo. Creo que esto se debe a las asignaciones de memoria que NIO crea que requieren la recolección de basura, como se describe enesta publicación.
 An̲̳̳drew29 jun. 2011 15:48
@Pete no parece que Apache Commons use nio todavía para copiar archivos.
 Jesse Glick28 ene. 2011 01:41
Tres posibles problemas con el código anterior: (a) si getChannel lanza una excepción, puede filtrar una secuencia abierta; (b) para archivos grandes, podría estar intentando transferir más de una vez de lo que el sistema operativo puede manejar; (c) está ignorando el valor de retorno de transferFrom, por lo que podría estar copiando solo una parte del archivo. Esta es la razón por la que org.apache.tools.ant.util.ResourceUtils.copyResource es tan complicado. También tenga en cuenta que mientras transferFrom está bien, transferTo rompe en JDK 1.4 en Linux:bugs.sun.com/bugdatabase/view_bug.do?bug_id=5056395
 user20742101 jun. 2013 03:30
Este código tiene unamayor problema. transferTo () debe llamarse en un bucle. No garantiza transferir la totalidad del importe solicitado.
 James P.15 ago. 2011 15:23
@Mark Renouf: Estoy obteniendo resultados mixtos con este código. No estoy seguro de lo que está sucediendo, pero los archivos copiados a veces tienen cero bytes.
 Ravi Wallau04 mar. 2009 22:35
Estoy de acuerdo en que es importante entender los antecedentes del nio, pero aún así me gustaría ir con los Comunes de Yakarta.
 Josh20 jun. 2013 01:13
@EJP Realmente ya no desarrollo en Java. Puede que tengas razón, por lo que puedes sugerir la forma correcta.
 Peter22 sept. 2008 19:19
Gracias, información útil. Aún abogo por algo como Apache Commons, especialmente si usa nio (correctamente) debajo; pero estoy de acuerdo en que es importante entender los fundamentos subyacentes.
 Anton K.12 ene. 2011 09:48
Desafortunadamente, hay advertencias. Cuando copié un archivo de 1.5 Gb en Windows 7, 32 bits, no se pudo asignar el archivo. Tuve que buscar otra solución.
 Mark Renouf28 mar. 2011 01:15
Creo que esta versión actualizada aborda esas preocupaciones:gist.github.com/889747

Su respuesta a la pregunta