java nio 文件拷贝_Java 复制大文件方式（nio2 FileChannel 拷贝文件能力测试）

最新推荐文章于 2023-04-26 14:04:06 发布
最新推荐文章于 2023-04-26 14:04:06 发布
阅读量281 收藏 1
点赞数
文章标签： java nio 文件拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_30611317/article/details/114201869
版权

目前为止，我们已经学习了很多 Java 拷贝文件的方式，除了 FileChannel 提供的方法外，还包括使用 Files.copy() 或使用字节数组的缓冲/非缓冲流。那个才是最好的选择呢？这个问题很难回答，因为答案基于很多因素。本文将目光集中到一个因素，那就是速度，因为拷贝任务 越快将会提高效率，在有些情况下，这是成功的关键。因此，本文将使用一个应用程序来比较下面这些拷贝方式的具体时间：

FileChannel 和非直接模式的 ByteBuffer

FileChannel 和直接模式的 ByteBuffer

FileChannel.transferTo()

FileChannel.transferFrom()

FileChannel.map()

使用字节数组和缓冲流

使用字节数组和非缓冲流

File.copy()(Path 到 Path，InputStream 到 Path 和 Path 到 OutputStream)

应用程序基于下面的条件：

拷贝文件类型 MP4 视频(文件名为 Rafa Best Shots.mp4，所在目录为 C:\rafaelnadal\tournaments\2009\videos)

文件大小：58.3MB

测试的缓冲区大小：4KB, 16KB, 32KB, 64KB, 128KB, 256KB, and 1024KB

机器配置：Mobile AMD Sempron Processor 3400 + 1.80 GHz, 1.00GB RAM, 32-bit

OS, Windows 7 Ultimate

测量类型：使用 System.nanoTime() 方法

连续运行三次后再获取时间；前三次运行将会被忽略。开始运行的时间总会比后面运行的时间要长一些。

下面将列出完整的应用程序：

import java.nio.MappedByteBuffer;

import java.io.OutputStream;

import java.io.InputStream;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

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.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.StandardOpenOption;

import java.util.EnumSet;

import static java.nio.file.LinkOption.NOFOLLOW_LINKS;

public class Main {

public static void deleteCopied(Path path){

try {

Files.deleteIfExists(path);

} catch (IOException ex) {

System.err.println(ex);

}

}

public static void main(String[] args) {

final Path copy_from = Paths.get("C:/rafaelnadal/tournaments/2009/videos/

Rafa Best Shots.mp4");

final Path copy_to = Paths.get("C:/Rafa Best Shots.mp4");

long startTime, elapsedTime;

int bufferSizeKB = 4; //also tested for 16, 32, 64, 128, 256 and 1024

int bufferSize = bufferSizeKB * 1024;

deleteCopied(copy_to);

//FileChannel and non-direct buffer

System.out.println("Using FileChannel and non-direct buffer ...");

try (FileChannel fileChannel_from = (FileChannel.open(copy_from,

EnumSet.of(StandardOpenOption.READ)));

FileChannel fileChannel_to = (FileChannel.open(copy_to,

EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {

startTime = System.nanoTime();

// Allocate a non-direct ByteBuffer

ByteBuffer bytebuffer = ByteBuffer.allocate(bufferSize);

// Read data from file into ByteBuffer

int bytesCount;

while ((bytesCount = fileChannel_from.read(bytebuffer)) > 0) {

//flip the buffer which set the limit to current position, and position to 0

bytebuffer.flip();

//write data from ByteBuffer to file

fileChannel_to.write(bytebuffer);

//for the next read

bytebuffer.clear();

}

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException ex) {

System.err.println(ex);

}

deleteCopied(copy_to);

//FileChannel and direct buffer

System.out.println("Using FileChannel and direct buffer ...");

try (FileChannel fileChannel_from = (FileChannel.open(copy_from,

EnumSet.of(StandardOpenOption.READ)));

FileChannel fileChannel_to = (FileChannel.open(copy_to,

EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {

startTime = System.nanoTime();

// Allocate a direct ByteBuffer

ByteBuffer bytebuffer = ByteBuffer.allocateDirect(bufferSize);

// Read data from file into ByteBuffer

int bytesCount;

while ((bytesCount = fileChannel_from.read(bytebuffer)) > 0) {

//flip the buffer which set the limit to current position, and position to 0

bytebuffer.flip();

//write data from ByteBuffer to file

fileChannel_to.write(bytebuffer);

//for the next read

bytebuffer.clear();

}

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException ex) {

System.err.println(ex);

}

deleteCopied(copy_to);

//FileChannel.transferTo()

System.out.println("Using FileChannel.transferTo method ...");

try (FileChannel fileChannel_from = (FileChannel.open(copy_from,

EnumSet.of(StandardOpenOption.READ)));

FileChannel fileChannel_to = (FileChannel.open(copy_to,

EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {

startTime = System.nanoTime();

fileChannel_from.transferTo(0L, fileChannel_from.size(), fileChannel_to);

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException ex) {

System.err.println(ex);

}

deleteCopied(copy_to);

//FileChannel.transferFrom()

System.out.println("Using FileChannel.transferFrom method ...");

try (FileChannel fileChannel_from = (FileChannel.open(copy_from,

EnumSet.of(StandardOpenOption.READ)));

FileChannel fileChannel_to = (FileChannel.open(copy_to,

EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {

startTime = System.nanoTime();

fileChannel_to.transferFrom(fileChannel_from, 0L, (int) fileChannel_from.size());

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException ex) {

System.err.println(ex);

}

deleteCopied(copy_to);

//FileChannel.map

System.out.println("Using FileChannel.map method ...");

try (FileChannel fileChannel_from = (FileChannel.open(copy_from,

EnumSet.of(StandardOpenOption.READ)));

FileChannel fileChannel_to = (FileChannel.open(copy_to,

EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {

startTime = System.nanoTime();

MappedByteBuffer buffer = fileChannel_from.map(FileChannel.MapMode.READ_ONLY,

0, fileChannel_from.size());

fileChannel_to.write(buffer);

buffer.clear();

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException ex) {

System.err.println(ex);

}

deleteCopied(copy_to);

//Buffered Stream I/O

System.out.println("Using buffered streams and byte array ...");

File inFileStr = copy_from.toFile();

File outFileStr = copy_to.toFile();

try (BufferedInputStream in = new BufferedInputStream(new FileInputStream(inFileStr));

BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFileStr))) {

startTime = System.nanoTime();

byte[] byteArray = new byte[bufferSize];

int bytesCount;

while ((bytesCount = in.read(byteArray)) != -1) {

out.write(byteArray, 0, bytesCount);

}

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException ex) {

System.err.println(ex);

}

deleteCopied(copy_to);

System.out.println("Using un-buffered streams and byte array ...");

try (FileInputStream in = new FileInputStream(inFileStr);

FileOutputStream out = new FileOutputStream(outFileStr)) {

startTime = System.nanoTime();

byte[] byteArray = new byte[bufferSize];

int bytesCount;

while ((bytesCount = in.read(byteArray)) != -1) {

out.write(byteArray, 0, bytesCount);

}

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException ex) {

System.err.println(ex);

}

deleteCopied(copy_to);

System.out.println("Using Files.copy (Path to Path) method ...");

try {

startTime = System.nanoTime();

Files.copy(copy_from, copy_to, NOFOLLOW_LINKS);

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException e) {

System.err.println(e);

}

deleteCopied(copy_to);

System.out.println("Using Files.copy (InputStream to Path) ...");

try (InputStream is = new FileInputStream(copy_from.toFile())) {

startTime = System.nanoTime();

Files.copy(is, copy_to);

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException e) {

System.err.println(e);

}

deleteCopied(copy_to);

System.out.println("Using Files.copy (Path to OutputStream) ...");

try (OutputStream os = new FileOutputStream(copy_to.toFile())) {

startTime = System.nanoTime();

Files.copy(copy_from, os);

elapsedTime = System.nanoTime() - startTime;

System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");

} catch (IOException e) {

System.err.println(e);

}

}

}

输出结果排序比较复杂，其中包含了很多数据。下面我将主要的对比用图形的方式展示出来。图形中 Y 坐标表示消耗的时间(单位：秒)，X 坐标表示缓冲的大小(或运行次数，跳过了前三次运行)。

FileChannel 和非直接模式 Buffer vs. FileChannel 和直接模式 Buffer

从下图看来，如果缓存小于 256KB，那么非直接模式的 Buffer 快一点，而缓存大于 256KB 后，直接模式的 Buffer 快一点：

8a17782f094e4b3cab0364dd40714e85.png

FileChannel.transferTo() vs. FileChannel.transferFrom() vs. FileChannel.map()

从下图看来，FileChannel.transferTo() 和 FileChannel.transferFrom 运行七次的速度都差不多，而 FileChannel.map 的速度就要差很多：

0a78958a7821c9f914771353b3084806.png

三种 Files.copy() 方法

从下图看来，最快的是 Path 到 Path，其次是 Path 到 OutputStream，最慢的是 InputStream 到 Path：

e49cd02f81910a01d036ed26816f24a6.png

FileChannel 和非直接模式 Buffer vs. FileChannel.transferTo() vs. Path 到 Path

最后，我们将前面最快的三种方式综合起来比较。从比较的结果来看，似乎 Path 到 Path 是最快的解决方案：

1eb7e538bf384002e3d00e1a09015519.png

骑着老鼠去偷菜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java使用nio2拷贝文件的示例
09-04
主要介绍了java使用nio2拷贝文件的示例,需要的朋友可以参考下
NIO与零拷贝_javanio_nio和零拷贝_
10-02
java nio和零拷贝 方面知识，适合对nio和零拷贝感兴趣的开发人员
nio.rar_NIO_java nio_java_nio_mina java n
09-23
nio教程，好的入门教材 ，
nio.rar_FastCopyFile.java_NIO_UseFloatBuffer.java_java nio_文件锁
09-24
Java NIO 源码适合初学者,里面包括通道和Buffer的基本适用,以及文件锁,和内存文件映射等等
Large-File-Processing-master_javanio_java大文件处理_
09-28
java 大文件处理。值得参考。基于nio。
Java中利用NIO复制文件的四种方法
MAX_YanBangbang的博客
07-28 2513
NIO简述 Java NIO （ New IO ）是从 Java 1.4 版本开始引入的一个新的 IO API ， 可以替代标准的 Java IO API 。NIO 与原来的 IO 有同样的作用和目的，但是使用的方式完全不同， NIO 支持面向缓冲区的、基于通道的 IO 操作。 NIO 将以更加高效的方式进行文件的读写操作. NIO与IO的区别 NIO ...
java 文件拷贝的四种方式
u013168615的专栏
12-26 8763
java 文件拷贝的四种方式
Java有几种文件拷贝方式？哪一种最高效
雪雪
04-26 332
ava.io的FileInputStream/FileOutputStream或者java.nio的transferTo/transferFrom。nio方式可能更快，因为使用了零拷贝技术，数据传输不需要切换到用户态参与，减少了上下文切换和不必要的内存拷贝。比如应用读取数据时，先在内核态将数据从磁盘读取到内核缓存，再切换到用户态将数据从内核缓存读取到用户缓存。而NIO transferTo则直接在内核中进行数据拷贝。
浅谈(Java)NIO实现零拷贝
程序员乌拉的博客！
04-30 1078
在 Java NIO 中的通道（Channel）就相当于操作系统的内核空间（kernel space）的缓冲区，而 缓冲区（Buffer）对应的相当于操作系统的 用户空间（user space）中的 用户缓冲区（user buffer）。
java nio copy_使用java NIO实现复制文件
weixin_32115639的博客
02-13 464
FileChannel src=new FileInputStream(new File(pathName_from)).getChannel();FileChannel dst=new FileOutputStream(new File(pathName_to)).getChannel();dst.transferFrom(src, 0, src.size());可能很多人以前都知道和使用过NI...
FileVisitor<T>
weixin_30851867的博客
09-01 116
package com.ant.jdk7; import java.io.IOException; import java.nio.file.*; import java.nio.file.attribute.BasicFileAttributes; public class FileVisitorDemo { public static void main(Stri...
java用NIO流拷贝文件
听风听雨的博客
10-21 925
import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; /** * 用NIO流拷贝文件 * @author 万星明 * @version 1.0...
NIO复制文件的三种方式对比
Java学习
10-09 597
下面对NIO复制文件的三种方式进行对比： 方式一：利用通道完成文件的复制（非直接缓冲区） @Test public void copyFirst(){ // 为了比较效率，记录程序执行时间 long startTime = System.currentTimeMillis(); // 开始时间 // 1 声明输入输出流 FileInputStream fis =...
JAVA功能代码《12》----使用NIO快速复制文件
web开发
05-21 282
12.使用NIO快速复制文件 public static void fileCopy(File in, File out) throws IOException { FileChannel inChannel = new FileInputStream(in).getChannel(); FileChannel outChannel = new FileOutputStream(ou...
5、java NIO 零拷贝技术
m0_45364328的博客
05-18 982
1、如果没有DMA 如果没有DMA的话，加入某一个客户端与服务器经过TCP三次握手后，服务器把内存中的100KB的数据传给客户端，那么数据就得传入到网卡上，我们直到cpu的运行速度是远大于内存速度大于网卡的速度的。那由于木桶效应，CPU的速度就会被拉低到和网卡一样的速度。 CPU会先把内存中的数据读到CPU高速缓冲区，再把数据写到网卡上 那么整个数据流程就是如下: ①CPU先把数据读到CPU的高速缓冲区 ②CPU再把数据从高速缓冲区读到网卡 2、如果存在DMA的话，上述向网卡传输数据的过程就会变...
java nio copy_java nio是如何实现零拷贝(zero-copy)的
weixin_39856208的博客
02-24 133
首先了解关于zero-copy相关的知识点java nio是如何实现zero-copy的在上一篇文章中简单介绍了zero-copy的相关知识，提到了mmap内存直接映射方式，这种方式介于sendfile系统调用与传统IO之间，其中一个重要原因是sendfile完全在内核空间中完成的，这对于应用程序来说就无法对数据进行操作，也由此，javaNIO是基于mmap内存映射的方式来实现零拷贝的。实现方式...
Java NIO文件复制
寂寞的博客
07-11 513
基于FileChannel复制文件。 普通的NIO复制 @Test public void testCopyFile() throws IOException { nioCopyFile("D:\\spark-2.2.3-bin-hadoop2.7.tgz", "D:\\spark-2.2.3-bin-hadoop2.7.tgz.copy"); } /** * @author jimo */ private void nioCop
Java NIO（网络io）（二）
weixin_45836787的博客
03-18 1031
一. 内存映射文件 1. MappedByteBuffer java处理大文件，一般用BufferedReader，BufferedInputStream这类带缓冲的IO类，不过，如果文件超大的话，更快的方式是MappedByteBuffer。 MappedByteBuffer是NIO引入的文件内存映射方案，读写性能极高。 MappedByteBuffer将文件直接映射到虚拟内存，如果文件比较大的话，可以分段映射。 2.MappedByteBuffer原理 3.FileChannel提供了m
Java NIO中的Files类的使用
m0_73533108的博客
09-19 4458
Java NIO中的Files类的使用
java nio拷贝文件
最新发布
07-12
NIO提供了更高效的I/O操作方式，特别是在处理大文件时。以下是一个使用NIO拷贝文件的示例代码： ```java import java.io.IOException; import java.io.FileInputStream; import java.io.FileOutputStream; import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值