Java文件拷贝的基本方法
在Java开发中，文件拷贝是一个常见但至关重要的操作。掌握多种文件拷贝方法能帮助开发者根据具体场景选择最优解决方案。
使用传统的IO流实现拷贝
Java传统的IO流提供了最基本的文件拷贝方式，适合所有Java版本：
public static void copyFileUsingStream(File source, File dest) throws IOException {
try (InputStream is = new FileInputStream(source);
OutputStream os = new FileOutputStream(dest)) {
byte[] buffer = new byte[1024];
int length;
while ((length = is.read(buffer)) > 0) {
os.write(buffer, 0, length);
}
}
}
这种方法虽然代码量稍多，但在处理大文件时可以控制内存使用，通过调整缓冲区大小优化性能。
使用NIO的Files.copy()方法
Java 7引入的NIO包提供了更简洁的文件拷贝方式：
public static void copyFileUsingNIO(Path source, Path dest) throws IOException {
Files.copy(source, dest, StandardCopyOption.REPLACE_EXISTING);
}
NIO方式不仅代码简洁，而且性能通常优于传统IO，特别是在大文件处理场景下。
Java文件拷贝的性能优化
缓冲区大小的选择策略
缓冲区大小直接影响拷贝效率：
- 小文件（<1MB）：4KB缓冲区足够
- 中等文件（1MB-100MB）：16KB-64KB缓冲区
- 大文件（>100MB）：128KB-1MB缓冲区
// 优化缓冲区大小的示例
public static void copyWithOptimizedBuffer(File source, File dest, int bufferSize)
throws IOException {
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source), bufferSize);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest), bufferSize)) {
byte[] buffer = new byte[bufferSize];
int bytesRead;
while ((bytesRead = bis.read(buffer)) > 0) {
bos.write(buffer, 0, bytesRead);
}
}
}
多线程分块拷贝技术
对于超大文件（GB级别），可以采用分块多线程拷贝：
public static void parallelCopy(File source, File dest, int chunkSize, int threadCount)
throws IOException, InterruptedException {
long fileSize = source.length();
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
for (long i = 0; i < fileSize; i += chunkSize) {
final long start = i;
final long end = Math.min(i + chunkSize, fileSize);
executor.submit(() -> {
try (RandomAccessFile rafIn = new RandomAccessFile(source, "r");
RandomAccessFile rafOut = new RandomAccessFile(dest, "rw")) {
rafIn.seek(start);
rafOut.seek(start);
byte[] buffer = new byte[8192];
long remaining = end - start;
while (remaining > 0) {
int read = rafIn.read(buffer, 0, (int) Math.min(buffer.length, remaining));
if (read == -1) break;
rafOut.write(buffer, 0, read);
remaining -= read;
}
} catch (IOException e) {
e.printStackTrace();
}
});
}
executor.shutdown();
executor.awaitTermination(1, TimeUnit.HOURS);
}
Java文件拷贝中的异常处理
常见异常类型及处理方案
- FileNotFoundException
- 检查源文件是否存在
-
验证目标目录是否可写
-
AccessDeniedException
- 检查文件权限
-
在Windows系统上注意文件是否被锁定
-
IOException
- 实现重试机制
- 添加适当的资源清理代码
健壮性拷贝实现示例
public static boolean robustCopy(Path source, Path target, int maxRetries) {
int attempts = 0;
while (attempts < maxRetries) {
try {
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
return true;
} catch (IOException e) {
attempts++;
if (attempts >= maxRetries) {
System.err.println("Failed to copy after " + maxRetries + " attempts: " + e.getMessage());
return false;
}
try {
Thread.sleep(100 * attempts); // 指数退避
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
return false;
}
}
}
return false;
}
高级Java文件拷贝技术
文件属性保留技术
在拷贝文件时，往往需要保留原始文件的属性：
public static void copyWithAttributes(Path source, Path target) throws IOException {
Files.copy(source, target, StandardCopyOption.COPY_ATTRIBUTES,
StandardCopyOption.REPLACE_EXISTING);
// 单独设置权限，因为COPY_ATTRIBUTES可能不会复制所有权限
try {
Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(source);
Files.setPosixFilePermissions(target, permissions);
} catch (UnsupportedOperationException e) {
// 非POSIX系统，忽略
}
// 设置最后修改时间
FileTime lastModifiedTime = Files.getLastModifiedTime(source);
Files.setLastModifiedTime(target, lastModifiedTime);
}
目录递归拷贝实现
处理目录拷贝需要递归处理所有子目录和文件：
public static void copyDirectory(Path source, Path target) throws IOException {
Files.walkFileTree(source, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
throws IOException {
Path targetDir = target.resolve(source.relativize(dir));
if (!Files.exists(targetDir)) {
Files.createDirectory(targetDir);
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
Files.copy(file, target.resolve(source.relativize(file)),
StandardCopyOption.REPLACE_EXISTING);
return FileVisitResult.CONTINUE;
}
});
}
Java文件拷贝的最佳实践
选择合适拷贝方法的决策树
- 小文件(<10MB)
- 优先使用
Files.copy() -
次选：缓冲流
-
中等文件(10MB-1GB)
- 缓冲流+适当缓冲区
-
考虑内存映射文件(MappedByteBuffer)
-
大文件(>1GB)
- 分块处理
- 考虑多线程拷贝
性能测试与监控
实现拷贝性能监控工具：
public class CopyMonitor {
public static void monitoredCopy(Path source, Path target,
Consumer<Long> progressCallback) throws IOException {
long totalBytes = Files.size(source);
long copiedBytes = 0;
try (InputStream in = Files.newInputStream(source);
OutputStream out = Files.newOutputStream(target)) {
byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
copiedBytes += bytesRead;
// 回调进度
if (progressCallback != null) {
progressCallback.accept(copiedBytes * 100 / totalBytes);
}
}
}
}
}
结语
Java文件拷贝看似简单，实则包含许多需要考虑的细节。从基本的IO操作到高级的NIO技术，再到性能优化和异常处理，每个环节都影响着程序的健壮性和效率。掌握这些技术后，开发者可以根据具体场景选择最适合的文件拷贝方案，确保数据安全高效地传输。
《Java文件拷贝：高效实现与最佳实践指南》.doc
将本文下载保存，方便收藏和打印
下载文档
