java基础专栏—IOBuffer（2）

缓冲概述

​ 在读写的操做中，读写操做的效率是十分重要的，sun公司提供了一套相应的类来提高效率。

​ ==IO对象==没有具体的操做，它是找操做系统来实现这个操做，因此每一个字节都去找操做系统，就会很慢，buffer就是先写入缓冲区，等写到必定的数量在一次性找操做系统写入文件。

BufferedOutputStream

​ 该类实现了缓冲的输出流，经过设置这种输出流，应用程序就能够将各个字节写入底层的输出流中，而没必要针对每一个字节调底层输出流。

|--OutputStream
	|--BufferedOutputStream

public BufferedOutputStream(OutputStream out)
  
public BufferedOutputStream(OutputStream out, int size)
  
public void write(byte[] b, int off, int len)
  
public void write(int b)将指定的字节写入此缓冲的输出流

public void flush()

FileOutputStream fos = new FileOutputStream("xxxx");

BufferedOutputStream bos = new BufferedOutputStream(fos);

bos.write("xxx");

byte[] bytes = "xxxx".getBytes();

bos.write(byte);

bos.close();

BufferedInputStream

咱们一直使用流对象就BufferedInputStream,打印流printStream

|--InputStream
	|--BufferedInputStream

public BufferedInputStream(InputStream in)

public BufferedInputStream(InputStream in, int size)
  
public void read(byte[] b);

public void flush();

FileInputStream

四种复制方法的效率比较

字节流读取单个字节

FileInputStream fis = null;
FileOutputStream fos = null;
int len = 0;

try{
    fis = new FileInputStream("xxx");
  	fos = new FileOutputStream("xxx");
  	while((len = fis.read()) != -1){
        fos.write((char)len);
    }
}catch(IOException ex){
    System.out.println(ex.getMessage("读写失败"));
}finally{
    if((fis != null) || (fos != null)){
     	try{
        	fis.close()
            fos.close()
    	}catch(IOException ex){
        	System.out.println(ex.getMessage("关闭流失败"));
    	}   
    }
}

字节流读取字符数组

FileInputStream fis = null;
FileOutputStream fos = null;
byte[] bytes = new byte[1024];
int len = 0;

try{
    fis = new FileInputStream("xxx");
  	fos = new FileOutputStream("xxx");
  	while((len = fis.read(bytes)) != -1){
        fos.write(bytes, 0 ,len);
    }
}catch(IOException ex){
    System.out.println(ex.getMessage("读写失败"));
}finally{
    if((fis != null) || (fos != null)){
     	try{
        	fis.close()
            fos.close()
    	}catch(IOException ex){
        	System.out.println(ex.getMessage("关闭流失败"));
    	}   
    }
}

字节流缓冲区读取单个字节

FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
int len = 0;

try{
    fis = new FileInputStream("xxx");
  	fos = new FileOutputStream("xxx");
	bis = new BufferedInputStream(fis);
	bos = new BufferedOutputStream(fos);
  	while((len = bis.read()) != -1){
        bos.write((char)len);
    }
}catch(IOException ex){
    System.out.println(ex.getMessage("读写失败"));
}finally{
    if((bis != null) || (bos != null)){
     	try{
        	bis.close()
            bos.close()
    	}catch(IOException ex){
        	System.out.println(ex.getMessage("关闭流失败"));
    	}   
    }
}

字节流缓冲区读取字符数组

FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
int len = 0;
byte[] bytes = new byte[1024];

try{
    fis = new FileInputStream("xxx");
  	fos = new FileOutputStream("xxx");
	bis = new BufferedInputStream(fis);
	bos = new BufferedOutputStream(fos);
  	while((len = bis.read(bytes)) != -1){
        bos.write(bytes, 0 ,len);
    }
}catch(IOException ex){
    System.out.println(ex.getMessage("读写失败"));
}finally{
    if((bis != null) || (bos != null)){
     	try{
        	bis.close()
            bos.close()
    	}catch(IOException ex){
        	System.out.println(ex.getMessage("关闭流失败"));
    	}   
    }
}

BufferedWriter

|--Writer
	|--OutputStreamWriter
	|--BufferedWriter
	
public BufferedWriter(Writer writer)
  
public void newLine()

BufferedReader

|--Reader
	|--InputStreamReader
	|--BufferedReader
	
public BufferedReader(Reader reader)

public String readLine()

IO流对象的使用步骤

1. 明确操做的是数据源还有数据目的
   1. 源，InputStream ，Reader
   2. 目的, OutputStrea， Writer
2. 要操做的是文本仍是字节
3. 明确数据所在的设备
   1. 硬盘，文件File对象
   2. 内存，数组，String
   3. 键盘，System.in，System.out
   4. 网络，Socker
4. 是否须要额外的功能
   1. 转换吗？转换流InputStreamReader，OutputStreamWriter
   2. 高效吗？BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter