一直困扰着我的是，在 Java 中复制文件的唯一方法是打开流、声明缓冲区、读入一个文件、循环通过它，然后将其写入另一个流。网络上充斥着类似但仍然略有不同的此类解决方案的实现。
有没有更好的方法可以保持在 Java 语言的范围内（意味着不涉及执行操作系统特定的命令）？也许在一些可靠的开源实用程序包中，这至少会掩盖这个底层实现并提供一个单一的解决方案？
270858 次
16 回答
279
我会避免使用像 apache commons 这样的大型 api。这是一个简单的操作，它内置在新 NIO 包中的 JDK 中。在之前的答案中已经链接到它，但是 NIO api 中的关键方法是新函数“transferTo”和“transferFrom”。
其中一篇链接的文章展示了如何使用 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。从个人经验来看，如果您没有经验并且通过 java.io 流被介绍给 IO，这可能是一件非常困难的事情。
于 2008-09-22T14:17:26.827 回答
276
正如上面提到的工具包，Apache Commons IO 是要走的路，特别是FileUtils。复制文件（）；它为您处理所有繁重的工作。
作为后记，请注意最近的 FileUtils 版本（例如 2.0.1 版本）添加了使用 NIO 来复制文件；NIO 可以显着提高文件复制性能，这在很大程度上是因为 NIO 例程将复制直接推迟到 OS/文件系统，而不是通过 Java 层读取和写入字节来处理它。因此，如果您正在寻找性能，可能值得检查您使用的是最新版本的 FileUtils。
于 2008-09-20T02:23:46.233 回答
182
现在使用 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() );
}
}
或者，更好的是，这也可以使用 Java 7 中引入的新 Files 类来完成：
public static void copyFile( File from, File to ) throws IOException {
Files.copy( from.toPath(), to.toPath() );
}
很时髦，嗯？
于 2011-07-28T18:22:35.277 回答
92
- 这些方法是针对性能设计的（它们与操作系统本机 I/O 集成）。
- 这些方法适用于文件、目录和链接。
- 提供的每个选项都可以省略 - 它们是可选的。
实用程序类
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 );
于 2013-05-17T03:09:21.707 回答
48
在 Java 7 中，这很容易......
File src = new File("original.txt");
File target = new File("copy.txt");
Files.copy(src.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING);
于 2014-06-20T18:38:26.580 回答
28
要复制文件并将其保存到目标路径，您可以使用以下方法。
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();
}
}
于 2013-10-23T13:08:53.413 回答
24
请注意，所有这些机制都只复制文件的内容，而不是权限等元数据。因此，如果您要在 linux 上复制或移动可执行的 .sh 文件，则新文件将无法执行。
为了真正复制或移动文件，即获得与从命令行复制相同的结果，您实际上需要使用本机工具。shell 脚本或 JNI。
显然，这可能在 java 7 - http://today.java.net/pub/a/today/2008/07/03/jsr-203-new-file-apis.html中得到修复。手指交叉！
于 2008-09-23T03:38:29.490 回答
23
Google 的 Guava 库也有一个复制方法：
公共静态无效副本（文件 来自， 文件 到） 抛出IOException
- 将所有字节从一个文件复制到另一个文件。
警告：如果
to表示现有文件，该文件将被from. 如果to和from引用同一个文件，该文件的内容将被删除。参数：
from- 源文件to- 目标文件抛出：
IOException- 如果发生 I/O 错误IllegalArgumentException- 如果from.equals(to)
于 2010-07-05T16:17:19.010 回答
18
在 Java 7 中作为标准提供，path.copyTo： http ://openjdk.java.net/projects/nio/javadoc/java/nio/file/Path.html http://java.sun.com/docs/books/教程/基本/io/copy.html
我不敢相信他们花了这么长时间来标准化像文件复制这样常见和简单的东西:(
于 2010-06-01T08:33:44.303 回答
7
上述代码可能存在的三个问题：
- 如果 getChannel 抛出异常，您可能会泄漏一个打开的流。
- 对于大文件，您可能会尝试一次传输超过操作系统处理能力的文件。
- 您忽略了 transferFrom 的返回值，因此它可能只是复制文件的一部分。
这就是为什么org.apache.tools.ant.util.ResourceUtils.copyResource如此复杂。另请注意，虽然 transferFrom 可以，但在 Linux 上的 JDK 1.4 上 transferTo 会中断（请参阅错误 ID：5056395） – Jesse Glick Jan
于 2012-04-13T09:36:31.757 回答
7
如果您在一个已经使用 Spring 的 Web 应用程序中，并且不想包含 Apache Commons IO 来进行简单的文件复制，则可以使用Spring 框架的FileCopyUtils。
于 2012-09-07T06:43:50.053 回答
6
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();
}
}
}
于 2014-01-16T01:25:45.143 回答
6
这里有三种方法可以轻松地用单行代码复制文件！
Java7：
private static void copyFileUsingJava7Files(File source, File dest) throws IOException {
Files.copy(source.toPath(), dest.toPath());
}
阿帕奇公共 IO：
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);
}
于 2014-11-13T11:57:18.453 回答
3
根据我的测试，带有缓冲区的 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();
}
}
}
}
于 2015-02-07T22:51:23.497 回答
2
快速并适用于所有版本的 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();
}
于 2013-11-14T09:43:21.147 回答
1
聚会有点晚了，但这里是使用各种文件复制方法复制文件所用时间的比较。我循环使用这些方法 10 次并取平均值。使用 IO 流进行文件传输似乎是最差的选择：
以下是方法：
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 通道类时看到的唯一缺点是我似乎仍然找不到显示中间文件复制进度的方法。
于 2018-05-30T10:50:52.433 回答