Java IO流学习总结三：缓冲流-BufferedInputStream、BufferedOutputStream

InputStream
|__FilterInputStream
        |__BufferedInputStream

private static int defaultBufferSize = 8192;//内置缓存字节数组的大小 8KB
	
protected volatile byte buf[];	//内置缓存字节数组
	
protected int count;	//当前buf中的字节总数、注意不是底层字节输入流的源中字节总数
	
protected int pos;		//当前buf中下一个被读取的字节下标
	
protected int markpos = -1;	//最后一次调用mark(int readLimit)方法记录的buf中下一个被读取的字节的位置
	
protected int marklimit;	//调用mark后、在后续调用reset()方法失败之前云寻的从in中读取的最大数据量、用于限制被标记后buffer的最大值

BufferedInputStream(InputStream in) //使用默认buf大小、底层字节输入流构建bis 

BufferedInputStream(InputStream in, int size) //使用指定buf大小、底层字节输入流构建bis 

int available();  //返回底层流对应的源中有效可供读取的字节数 
void close();  //关闭此流、释放与此流有关的所有资源 
boolean markSupport();  //查看此流是否支持mark
void mark(int readLimit); //标记当前buf中读取下一个字节的下标 
int read();  //读取buf中下一个字节 
int read(byte[] b, int off, int len);  //读取buf中下一个字节 
void reset();   //重置最后一次调用mark标记的buf中的位子 
long skip(long n);  //跳过n个字节、 不仅仅是buf中的有效字节、也包括in的源中的字节 

protected byte[] buf;   //内置缓存字节数组、用于存放程序要写入out的字节 
protected int count;   //内置缓存字节数组中现有字节总数 

BufferedOutputStream(OutputStream out); //使用默认大小、底层字节输出流构造bos。默认缓冲大小是 8192 字节( 8KB )
BufferedOutputStream(OutputStream out, int size);  //使用指定大小、底层字节输出流构造bos 

/** * Creates a new buffered output stream to write data to the * specified underlying output stream. * @param out the underlying output stream. */
public BufferedOutputStream(OutputStream out) { 

this(out, 8192);
}
/** * Creates a new buffered output stream to write data to the * specified underlying output stream with the specified buffer * size. * * @param out the underlying output stream. * @param size the buffer size. * @exception IllegalArgumentException if size <= 0. */
public BufferedOutputStream(OutputStream out, int size) { 

super(out);
if (size <= 0) { 

throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}

//在这里提一句,`BufferedOutputStream`没有自己的`close`方法,当他调用父类`FilterOutputStrem`的方法关闭时,会间接调用自己实现的`flush`方法将buf中残存的字节flush到out中,再`out.flush()`到目的地中,DataOutputStream也是如此。 
void  flush();  将写入bos中的数据flush到out指定的目的地中、注意这里不是flush到out中、因为其内部又调用了out.flush()  
write(byte b);      将一个字节写入到buf中  
write(byte[] b, int off, int len);      将b的一部分写入buf中 

package com.app;
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.InputStream;
import java.io.OutputStream;
public class A3 { 

public static void main(String[] args) throws IOException { 

String filePath = "F:/123.png" ;
String filePath2 = "F:/abc.png" ;
File file = new File( filePath ) ;
File file2 = new File( filePath2 ) ;
copyFile( file , file2 );
}
/** * 复制文件 * @param oldFile * @param newFile */
public static void copyFile( File oldFile , File newFile){ 

InputStream inputStream = null ;
BufferedInputStream bufferedInputStream = null ;
OutputStream outputStream = null ;
BufferedOutputStream bufferedOutputStream = null ;
try { 

inputStream = new FileInputStream( oldFile ) ;
bufferedInputStream = new BufferedInputStream( inputStream ) ;
outputStream = new FileOutputStream( newFile ) ;
bufferedOutputStream = new BufferedOutputStream( outputStream ) ;
byte[] b=new byte[1024];   //代表一次最多读取1KB的内容
int length = 0 ; //代表实际读取的字节数
while( (length = bufferedInputStream.read( b ) )!= -1 ){ 

//length 代表实际读取的字节数
bufferedOutputStream.write(b, 0, length );
}
//缓冲区的内容写入到文件
bufferedOutputStream.flush();
} catch (FileNotFoundException e) { 

e.printStackTrace();
}catch (IOException e) { 

e.printStackTrace();
}finally { 

if( bufferedOutputStream != null ){ 

try { 

bufferedOutputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
if( bufferedInputStream != null){ 

try { 

bufferedInputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
if( inputStream != null ){ 

try { 

inputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
if ( outputStream != null ) { 

try { 

outputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}
}
}

finally { 

if( bufferedOutputStream != null ){ 

try { 

bufferedOutputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
if( bufferedInputStream != null){ 

try { 

bufferedInputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
if( inputStream != null ){ 

try { 

inputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
if ( outputStream != null ) { 

try { 

outputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}

   /** * Closes this input stream and releases any system resources * associated with the stream. * Once the stream has been closed, further read(), available(), reset(), * or skip() invocations will throw an IOException. * Closing a previously closed stream has no effect. * * @exception IOException if an I/O error occurs. */
public void close() throws IOException { 

byte[] buffer;
while ( (buffer = buf) != null) { 

if (bufUpdater.compareAndSet(this, buffer, null)) { 

InputStream input = in;
in = null;
if (input != null)
input.close();
return;
}
// Else retry in case a new buf was CASed in fill()
}
}

finally { 

if( bufferedOutputStream != null ){ 

try { 

bufferedOutputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
if( bufferedInputStream != null){ 

try { 

bufferedInputStream.close();
} catch (IOException e) { 

e.printStackTrace();
}
}
}