java文件字节缓冲流,JavaIO 使用缓冲字节流和文件字节流拷贝文件

文件字节流复制文件的原理是：读取一个个字节(或者字节数组)，然后再写入文件中去。

缓冲字节流复制文件的原理是：读取一个个字节(或者字节数组)放到缓冲字节数组中，等到缓冲字节数组读满后，再把这几次读取到的字节一并写到文件中去。这样使用缓冲字节流，就能少写几次文件，进而节省时间。

测试代码：

(1)批量读取比较：public class TestBuffered_File

{

public static void copyFileBufferd(File srcFile,File destFile,int bufsize) throws IOException

{

if(!srcFile.exists())

{

throw new FileNotFoundException("文件"+srcFile+"不存在");

}

if(!srcFile.isFile())

{

throw new IllegalArgumentException(srcFile+"不是文件");

}

//创建缓冲字节流对象，内部缓冲设置为bufSize

BufferedInputStream in=new BufferedInputStream(

new FileInputStream(srcFile),bufsize);

BufferedOutputStream out=new BufferedOutputStream(

new FileOutputStream(destFile),bufsize);

int size=0;

byte[] buffer=new byte[512];

//读到字节串到内部缓存，默认缓冲区的大小是8192字节

while((size=in.read(buffer))!=-1)

{

out.write(buffer,0,size);//把读取到的字节串写入到缓冲区，缓冲区写满会自动写入文件

//out.flush();//刷新缓冲区写入文件

}

out.flush();//刷新缓冲区写入文件

in.close();

out.close();

}

/**

* 使用FileInputStream和FileOutputStream 按字节数组拷贝文件

* @param srcFile 源文件File对象

* @param targetFile 目标文件File对象

* @throws IOException

*/

public static void copyFileByBytes(File srcFile,File targetFile) throws IOException

{

if(!srcFile.exists())

{

throw new IllegalArgumentException( srcFile+"文件不存在");

}

if(!srcFile.isFile())

{

throw new IllegalArgumentException( srcFile+"不是文件");

}

FileInputStream in=new FileInputStream(srcFile);

FileOutputStream out=new FileOutputStream(targetFile);

byte[] buf=new byte[512];

int size=0;

while((size=in.read(buf, 0, buf.length))!=-1)

{

out.write(buf, 0, size);

out.flush();//刷新写入文件中去。

}

in.close();

out.close();

}

/**

* 把时间戳(long 毫秒数)转换为格式化时间字符串

* @param timeStamp long毫秒数

* @return 格式化时间字符串

*/

public static String timeStampToDateString(long timeStamp)

{

Date date = new Date(timeStamp);

/*

m 小时中的分钟数

s 分钟中的秒数

S 毫秒数

*/

DateFormat format = new SimpleDateFormat("mm:ss:SS");

String dateString=format.format(date);

return dateString;

}

public static void main(String[] args)

{

String packagePath;

try

{

//使用缓冲字节流拷贝文件

long start=System.currentTimeMillis();//获取当前的时间戳

packagePath = FilePath.getSrcPackagePath(TestBufferedCopy.class);

copyFileBufferd(new File(packagePath+"李玉刚_刚好遇见你.mp3"),

new File(packagePath+"李玉刚_刚好遇见你副本4.mp3"),1024*10);

long end=System.currentTimeMillis();//获取复制后的时间戳

System.out.println("使用缓冲字节流(每次读取字节数组512)拷贝文件用时(分钟:秒:毫秒)："

+timeStampToDateString(end-start));

//使用文件字节流，按字节数组拷贝文件

start=System.currentTimeMillis();

copyFileByBytes(new File(packagePath+"李玉刚_刚好遇见你.mp3"),

new File(packagePath+"李玉刚_刚好遇见你副本5.mp3"));

end=System.currentTimeMillis();

System.out.println("使用文件字节流(每次读取字节数组512)拷贝文件用时(分钟:秒:毫秒)："

+timeStampToDateString(end-start));

} catch (UnsupportedEncodingException e1)

{

e1.printStackTrace();

} catch (IOException e)

{

e.printStackTrace();

}

}

}

运行结果：使用缓冲字节流(每次读取字节数组512)拷贝文件用时(分钟:秒:毫秒)：00:00:34

使用文件字节流(每次读取字节数组512)拷贝文件用时(分钟:秒:毫秒)：00:00:101

可见，每次读取相同的字节数组的条件下，缓冲字节流多了缓冲，进而减少写入文件的次数，从而比文件字节流用时少。

(2)逐个字节读取比较：import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.Date;

import com.lan.filepath.FilePath;

public class TestBuffered_FileByByte

{

public static void copyFileBufferdByByte(File srcFile, File destFile, int bufsize)

throws IOException

{

if (!srcFile.exists())

{

throw new FileNotFoundException("文件" + srcFile + "不存在");

}

if (!srcFile.isFile())

{

throw new IllegalArgumentException(srcFile + "不是文件");

}

// 创建缓冲字节流对象，内部缓冲设置为bufSize

BufferedInputStream in = new BufferedInputStream(

new FileInputStream(srcFile), bufsize);

BufferedOutputStream out = new BufferedOutputStream(

new FileOutputStream(destFile), bufsize);

int size = 0;

// 读到字节串到内部缓存，默认缓冲区的大小是8192字节

while ((size = in.read()) != -1)

{

out.write(size);// 把读取到的字节写入到缓冲区，缓冲区写满会自动写入文件

}

out.flush();// 刷新缓冲区写入文件

in.close();

out.close();

}

/**

* 使用FileInputStream和FileOutputStream 按字节数组拷贝文件

*

* @param srcFile

* 源文件File对象

* @param targetFile

* 目标文件File对象

* @throws IOException

*/

public static void copyFileByByte(File srcFile, File targetFile)

throws IOException

{

if (!srcFile.exists())

{

throw new IllegalArgumentException(srcFile + "文件不存在");

}

if (!srcFile.isFile())

{

throw new IllegalArgumentException(srcFile + "不是文件");

}

FileInputStream in = new FileInputStream(srcFile);

FileOutputStream out = new FileOutputStream(targetFile);

int size = 0;

while ((size = in.read()) != -1)

{

out.write(size);

}

in.close();

out.close();

}

/**

* 把时间戳(long 毫秒数)转换为格式化时间字符串

*

* @param timeStamp

* long毫秒数

* @return 格式化时间字符串

*/

public static String timeStampToDateString(long timeStamp)

{

Date date = new Date(timeStamp);

/*

* m 小时中的分钟数 s 分钟中的秒数 S 毫秒数

*/

DateFormat format = new SimpleDateFormat("mm:ss:SS");

String dateString = format.format(date);

return dateString;

}

public static void main(String[] args)

{

String packagePath;

try

{

// 使用缓冲字节流拷贝文件

long start = System.currentTimeMillis();// 获取当前的时间戳

packagePath = FilePath.getSrcPackagePath(TestBufferedCopy.class);

copyFileBufferdByByte(new File(packagePath + "李玉刚_刚好遇见你.mp3"),

new File(packagePath + "李玉刚_刚好遇见你副本6.mp3"), 1024 * 10);

long end = System.currentTimeMillis();// 获取复制后的时间戳

System.out.println("使用缓冲字节流(逐个字节)拷贝文件用时(分钟:秒:毫秒)："

+ timeStampToDateString(end - start));

// 使用文件字节流，按字节数组拷贝文件

start = System.currentTimeMillis();

copyFileByByte(new File(packagePath + "李玉刚_刚好遇见你.mp3"),

new File(packagePath + "李玉刚_刚好遇见你副本7.mp3"));

end = System.currentTimeMillis();

System.out.println("使用文件字节流(逐个字节)拷贝文件用时(分钟:秒:毫秒)："

+ timeStampToDateString(end - start));

} catch (UnsupportedEncodingException e1)

{

e1.printStackTrace();

} catch (IOException e)

{

e.printStackTrace();

}

}

}

运行结果：使用缓冲字节流(逐个字节)拷贝文件用时(分钟:秒:毫秒)：00:00:279

使用文件字节流(逐个字节)拷贝文件用时(分钟:秒:毫秒)：00:35:982

可以看到逐个字节逐个字节的来拷贝文件，使用文件字节流要读一个字节写一个字节，耗时很大。虽然也是每次读取一个字节一个字节的读取，但是使用缓冲字节流读取满缓冲，才写一次文件，也就是读取1024 * 10次，才写一次文件。相比于使用文件字节流节省了1024 * 10-1次写文件的操作。这样就节省更多的时间。

总结：

(1) 如果使用文件字节流，复制文件，每次读取一个数组，写一个数组，比每次读取一个字节，写一个字节更快。

(2) 使用缓冲字节流比文件字节流更快(多分配内存(缓冲))：每次读取一个数组放到一个大的数组中去(缓冲)，然后大的数组(缓冲)满了再一次性写入。