最近在学习netty，其中有对比bio、nio、netty使用上的不同，也趁此机会回顾了相关知识，加深下理解，主要涉及的有FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream、FileChannel、MappedByteBuffer等知识点。
一、FileIn(Out)putStream（单字节）
public static void fileCopy(String src,String dest) throws IOException{
long t = System.currentTimeMillis();
File file = new File(src);
try(
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest));
){
int result = 0;
while((result = fis.read()) != -1){
fos.write(result);
}
}
System.err.println("file copy use time="+(System.currentTimeMillis()-t)+" file.size="+(file.length()/1024/1024)+"MB");
}
控制台输出：
file copy use time=62065 file.size=20MB
从输出接口可以看到，20MB文件copy用时一分钟多，可见不使用缓冲区，单字节读写时执行慢的无法接受。
这里使用了try-with-resources的方式来进行流的自动关闭，对该知识点不熟悉的可参考Java 7中的Try-with-resources;
二、FileIn(Out)putStream（字节数组）
public static void fileCopyWithBuffer(String src,String dest) throws IOException{
long t = System.currentTimeMillis();
File file = new File(src);
try(
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest));
){
byte[] buffer = new byte[1024];
int byteRead = 0;
while((byteRead = fis.read(buffer)) != -1){
fos.write(buffer,0,byteRead);
}
}
System.err.println("fileCopyWithBuffer use time="+(System.currentTimeMillis()-t)+" file.size="+(file.length()/1024/1024)+"MB");
}
控制台输出：
fileCopyWithBuffer use time=140 file.size=20MB
可见使用buffer进行批量读写后，性能有了质的提高.
下面我们来调整buffer数组的长度为10240，看下输出：
fileCopyWithBuffer use time=45 file.size=20MB
经过多次尝试，发现适当的增加buffer的长度，可以明显提升处理速度。
三、BufferedIn(Out)putStream(单字节)
public static void fileCopyWithBufferStream(String src,String dest) throws IOException{
long t = System.currentTimeMillis();
File file = new File(src);
try(
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest));
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
){
int result = 0;
while((result =bis.read()) != -1){
bos.write(result);
}
}
System.err.println("fileCopyWithBufferStream use time="+(System.currentTimeMillis()-t)+" file.size="+(file.length()/1024/1024)+"MB");
}
控制台输出：
fileCopyWithBufferStream use time=1199 file.size=20MB
相对于单字节的流读写方式，处理时间有62s提升至1.2s，提升还是很大的。
BufferedInputStream创建时内部会默认创建一个长度8192的byte数组，read方法实际上是在这个内存数组里面读取数据，下面我们看下read方法的源码：
public synchronized int read() throws IOException {
if (pos >= count) { // 当数据已读完时
fill(); // 调用上层inputStream内read方法读取数据填充buf
if (pos >= count) // 如果仍无可读数据，说明数据已读完
return -1;
}
//从此处可看到read操作实际读取的是buf数组的数据
//& 0xff的目的是消除后八位之前的位数据，保证读出的字节数据无变化，防止首位为1的情况转为int时高位为填充为1
return getBufIfOpen()[pos++] & 0xff;
}
- 当缓存区无可读数据时，调用fill方法，fill方法内部会考虑mark和reset的逻辑，设置新读入数据再数组内的存放位置
- 调用InputStream内的read(byte b[], int off, int len)方法进行数据的“批量”读取；
- 调用bis.read()时，从buffer内返回数据
“批量”的读数据，从而提高了整体的执行速度。fill()方法的实现此处不再展开，可参考BufferedInputStream源码分析.
BufferedOutputStream的write方法，也是先将数据存入buf，当buf存满时，将数据刷出；
public synchronized void write(int b) throws IOException {
if (count >= buf.length) {
flushBuffer();
}
buf[count++] = (byte)b;
}
四、BufferedIn(Out)putStream(多字节)
public static void fileCopyWithBufferStreamAndBuffer(String src,String dest) throws IOException{
long t = System.currentTimeMillis();
File file = new File(src);
try(
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest));
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
){
byte[] buffer = new byte[1024];
int byteRead = 0;
while((byteRead = bis.read(buffer)) != -1){
bos.write(buffer,0,byteRead);// 1
//bos.write(buffer); // 2
// 1和2的区别是，最后一次读取的数据可能不能放满buffer，那样上一次留存的数据就会
// 被一起写出，可以通过定义一个15长度的byte数组，写出时使用长度10的byte数组，就能看到结果了
}
}
System.err.println("fileCopyWithBufferStreamAndBuffer use time="+(System.currentTimeMillis()-t)+" file.size="+(file.length()/1024/1024)+"MB");
}
控制台输出：
fileCopyWithBufferStreamAndBuffer use time=99 file.size=20MB
可见使用buffer进行批量读写后，性能有了质的提高.
下面我们来调整buffer数组的长度为10240，看下输出：
fileCopyWithBufferStreamAndBuffer use time=46 file.size=20MB
经过多次尝试，发现适当的增加buffer的长度，可以明显提升处理速度。
五、FileChannel
public static void fileCopyWithChannel(String src,String dest) throws IOException{
long t = System.currentTimeMillis();
File file = new File(src);
try(
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest));
FileChannel in = fis.getChannel();
FileChannel out = fos.getChannel();
){
in.transferTo(0, in.size(), out);
}
System.err.println("fileCopyWithChannel use time="+(System.currentTimeMillis()-t)+" file.size="+(file.length()/1024/1024)+"MB");
}
控制台输出：
fileCopyWithChannel use time=85 file.size=20MB
从输出结果看，单纯的copy文件上，使用Channel并无明显的性能优势。
ps:transferTo方法比较耗费内存资源，建议只在小文件或小使用量时使用，避免出现资源不足等异常。
NIO的关键点是通道和缓冲区，这里不再过多展开，NIO入门推荐Java NIO 系列教程。
六、FileChannel（ByteBuffer）
public static void nioBufferCopy(String src,String dest) throws IOException {
long t = System.currentTimeMillis();
File file = new File(src);
try(
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest));
FileChannel in = fis.getChannel();
FileChannel out = fos.getChannel();
){
ByteBuffer buffer = ByteBuffer.allocate(4096);
while (in.read(buffer) != -1) {
buffer.flip();
out.write(buffer);
buffer.clear();
}
}
System.err.println("nioBufferCopy use time="+(System.currentTimeMillis()-t)+" file.size="+(file.length()/1024/1024)+"MB");
}
控制台输出：
nioBufferCopy use time=182 file.size=20MB
下面我们来调整buffer数组的长度为40960，看下输出：
nioBufferCopy use time=60 file.size=20MB
七、FileChannel（MappedByteBuffer）
public static void nioMappedByteBufferCopy(String src,String dest) throws IOException {
long t = System.currentTimeMillis();
File file = new File(src);
try(
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest));
FileChannel in = fis.getChannel();
FileChannel out = fos.getChannel();
){
MappedByteBuffer mappedByteBuffer = in.map(MapMode.READ_ONLY, 0, in.size());
out.write(mappedByteBuffer);
}
System.err.println("nioMappedByteBufferCopy use time="+(System.currentTimeMillis()-t)+" file.size="+(file.length()/1024/1024)+"MB");
}
控制台输出：
nioMappedByteBufferCopy use time=50 file.size=20MB
使用内存映射文件的方式速度还是比较理想的，更多内容推荐阅读深入浅出MappedByteBuffer,另外，推荐关注占小狼，他写的精品文章很多！
八、Buffered(Reader)Writer
字符流的使用相对简单，这里给出一个示例代码。
public static void bufferReaderWriterTest() throws IOException{
List list = new ArrayList(20);
for(int i=0;i<20;i++){
list.add(""+i);
}
File file = new File("brwtest.txt");
try(
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
BufferedReader br = new BufferedReader(new FileReader(file));
){
for (String item : list) {
bw.write(item);
bw.newLine();
}
//此处不调用flush方法，下边读取时内容会为空
bw.flush();
String line = null;
while ((line = br.readLine()) != null) {
System.err.println(line);
}
//org.apache.commons.io.IOUtils，有许多工具包内提供了IO操作方法，可以优先考虑使用
// List lines = IOUtils.readLines(br);
// for (String string : lines) {
// System.err.println(string);
// }
}
}
小结
我个人写这篇文章或者说写这些demo代码的收获有：
- 自以为很熟悉的I/O类，动起手来才发现自己离“顺手拈来”还有一段不小的差距；
- 从源码层面了解不同流的实现方式，更深一层的提高了自己对java I/O知识的理解；
- 发现了过往所学知识的弱点，看别人博客进行学习，大致知其然，未系统梳理，未动手练习，未理解其实现方式和原理，浮于表面，随着时间的流逝，这些知识成了零散模糊的片段。
I/O是java中基础的知识点，你不妨也闭起眼思考下你能使用多少种不同的方式实现文件复制，或许你会有不同的发现！
ps:本机mac air，测试代码有其随意性，copy速度仅能体现量级上的趋势，以供参考。