JAVA中几种文件操作流的效率对比

傷城~ 2022-07-13 15:29 434阅读 0赞

以下案例说明了分别采用字节流方式、字节缓冲流方式读写文件的效率对比

package ioxcercise;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Comparator;

import java.util.Set;

import java.util.TreeMap;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

/\*

\* 需求：把其他目录下的视频文件复制到指定目录中

\* 视频文件大小：49MB

\* 要求使用字节流的四种方式复制文件，比较四种方式的耗时：

\* 基本字节流一次读写一个字节

\* 基本字节流一次读写一个字节数组

\* 高效字节流一次读写一个字节

\* 高效字节流一次读写一个字节数组

\*/

public class ioRWcomparation \{

public staticvoid main(String\[\] args)throws IOException \{

String from =  "D:\\\\1oldBoy\_4\\\\1216\\\\day12\\\\videos\_day12\\\\testvideo.avi";

String to =  "D:\\\\1oldBoy\_4\\\\1216\\\\day18\\\\testvideo.rmvb";

TreeMap<Integer,String> hm =  new TreeMap<Integer,String>(new Comparator<Integer>()\{

@Override

public int compare(Integer int1, Integer int2) \{

int num = int1 - int2;

int num2 = num == 0 ? int1.compareTo(int2) : num;

**return** num2;

\});

//字节流：每次写入单个字节的耗时

long long1 = SimpleIoStream(from, to);

hm.put((int) long1,"字节流：每次写入单个字节的耗时(毫秒)");

//字节流：每次写入指定长度的字节数组的耗时

long long2 = MultiWritingStream(from, to);

hm.put((int) long2,"字节流：每次写入指定长度的字节数组的耗时(毫秒)");

//字节缓冲流：每次写入单个字节的耗时

long long3 = highEfficientSimpleStream(from, to);

hm.put((int)long3,"字节缓冲流：每次写入单个字节的耗时(毫秒)");

//字节缓冲流：每次写入指定长度的字节数组的耗时

long long4 = highEfficientMultiStream(from, to);

hm.put((int)long4,"字节缓冲流：每次写入指定长度的字节数组的耗时(毫秒)");

Set<Integer> set = hm.keySet();

for(Integer i : set)\{

System.out.println(hm.get(i)+" : "\+i);

private staticlong highEfficientMultiStream(String from, String to)throws IOException\{

long start = System.currentTimeMillis();

BufferedInputStream bis =  new BufferedInputStream(new FileInputStream(from));

BufferedOutputStream bos =  new BufferedOutputStream(new FileOutputStream(to));

byte\[\] readBytes =newbyte\[1024\];

int readResult = 0;

while((readResult = bis.read(readBytes)) != -1)\{

bos.write(readBytes, 0, readResult);  //高效字节流一次读写一个字节数组

**return** System.currentTimeMillis() - start;

private staticlong highEfficientSimpleStream(String from, String to)throws IOException\{

long start = System.currentTimeMillis();

BufferedInputStream bis =  new BufferedInputStream(new FileInputStream(from));

BufferedOutputStream bos =  new BufferedOutputStream(new FileOutputStream(to));

int len = 0;

while((len=bis.read()) != -1)\{ //高效字节流一次读写一个字节

bos.write(len);

bis.close(); bos.close();

**return** System.currentTimeMillis() - start;

private  static long MultiWritingStream(String from, String to)throws IOException \{

long start = System.currentTimeMillis();

FileInputStream fis =  new FileInputStream(from);

FileOutputStream fos =  new FileOutputStream(to);

int len = 0;

byte\[\] bArr =newbyte\[2048\];

while((len=fis.read(bArr)) != -1)\{ //基本字节流:一次读写一个字节数组

fos.write(bArr, 0, len);

fis.close(); fos.close();

**return** System.currentTimeMillis() - start;

public  static long SimpleIoStream(String from, String to)throws IOException \{

long start = System.currentTimeMillis();

FileInputStream fis =  new FileInputStream(from);

FileOutputStream fos =  new FileOutputStream(to);

int len = 0;

while ((len = fis.read()) != -1) \{ //基本字节流:一次读写一个字节

fos.write(len);

fis.close(); fos.close();

**return** System.currentTimeMillis() - start;

【使用大小为49MB的视频读写结果】

字节缓冲流：每次写入指定长度的字节数组的耗时(毫秒) : 212

字节流：每次写入指定长度的字节数组的耗时(毫秒) : 527

字节缓冲流：每次写入单个字节的耗时(毫秒) : 1134

字节流：每次写入单个字节的耗时(毫秒) : 710350

可以看出，缓冲流方式的读写速率明显比非缓冲流要大，每次读写字节数组的速率明显大于每次读写单个字节的速率.

JAVA中几种文件操作流的效率对比

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java集合框架操作效率对比

相关 Java中集合操作效率对比示例

相关 Java文件操作和IO流效率提升

相关 Mysql中几种插入效率的实例对比

相关几种Java读写数据的流性能对比

相关 java 读取文件效率_java读取文件的几种方式性能比较

相关 Java反射三种方式的效率对比

相关 Linux下的几种文件拷贝方式效率对比

相关 JAVA中几种文件操作流的效率对比

相关 java 几种拼接字符串的效率