常用IO流的使用方式

 常用IO流这里指的是用于对文件的读取操作的IO流，IO流分类两大类，分别是字节流和字符流，字节流相关类用于处理字节相关文件，比如视频、音频、图片、格式化文件等。字符流相关类用于处理字符相关文件，比如.txt之类的文件没有格式的文件。

一、常用字符流
Reader:字符输入流,是一个抽象类其子类必须实现read(char[], int, int)和close()方法
BufferedReader:从字符输入流中读取文本，缓冲字符以便提供对字符、数组和行的有效读取。可以指定缓冲区的大小也可以使用默认大小（足够了）
CharArrayReader:源是字符的字符输入流。
StringReader:源是字符串的字符流。
InputStreamReader:字节输入流到字符输入流的桥梁，并使用指定的字符集将字节解码为字符。
可以在BufferedReader中包装一个InputStreamReader来提高字节的读取效率。
构造方法：
InputStreamReader(InputStream in):实用默认字符集创建“字节-字符”对象
InputStreamReader(InputStream in, Charset cs):使用给定的字符继创建“字节-字符”对象
InputStreamReader(InputStream in, CharsetDecoder dec):创建一个使用给定字符集解码器的InputStreamReader。
InputStreamReader(InputStream in, String charsetName):创建一个使用名为charsetName的InputStreamReader。
常用方法：
String getEncoding():返回该流的字符编码名称
int read():读取单一字符。
int read(char[] cbuf, int offset, int length):将字符读入数组的一部分。
boolean ready():是否准备好开始读取字符。
void close():关闭流。
InputStreamReader子类：
FileReader:用来读取字符输入流文件的

Writer:字符输出流
BufferedWriter:文本写入字符输出流，缓冲字符。提供单个字符、数组和字符串的高效写入
CharArrayWriter:字符缓冲输出流，用于写入字符数据。可以用户toCharArray()和toString()方法来检索数据。
OutputStreamWriter:字符输出流到字节输出流的桥梁，用指定的字符集将字符编码成字节。为了达到最高效率，
可以在BufferedWriter中包装一个OutputStreamWriter来提高字符转换成字节的效率。
构造方法：
OutputStreamWriter(OutputStream out)：使用默认字符集编码创建OutputStreamWriter
OutputStreamWriter(OutputStream out, Charset cs):使用指定字符集编码创建OutputStreamWriter
OutputStreamWriter(OutputStream out, CharsetEncoder enc)：使用指定编码器创建OutputStreamWriter
OutputStreamWriter(OutputStream out, String charsetName)：使用命名字符集来创建OutputStreamWriter
常用方法：
void close()：在刷新流之前关闭流。
void flush()：刷新流
String getEncoding()：获取字符集的编码
void write(char[] cbuf, int off, int len):写入字符数组的一部分。
void write(int c)：写入单个字符
void write(String str, int off, int len)：写入字符串的一部分。
OutputStreamWriter的子类：
FileWriter：用来写入字符输出流到指定文件

二、常用字节流
InputStream:字节输入流
BufferedInputStream:缓存字节输入流，能够对输入流中的字节进行缓冲。提供了标记方法mark()和重置方法reset(),当BufferedInputStream
被创建时内部缓冲区即被创建，默认缓存区大小是8M。
ByteArrayInputStream:以字节数组保存数据，包含一个内部缓冲区，可以从流中读取的字节。内部计数器为read()方法提供需要跟踪的下一个字节。
FileInputStream:从文件系统中获取文件的输入字节流，
OutputStream:字节输出流
BufferedOutputStream:缓冲字节输出流，可以将字节写入底层的输出流。
ByteArrayOutputStream:以字节数组保存数据，缓冲字节输出流，数据被写入一个字节数组，当数据写入时，缓冲区会自动增长。使用toByteArray()和toString()来检索数据。
FileOutputStream:文件输出流，是将字节流写入文件或者文件描述当中

三、常用文件处理流
File:文件和目录路径名的抽象类
FileInputStream:从文件系统中获取文件的输入字节流。
FileReader:用来读取字符输入流文件的
FileOutputStream:文件输出流，是将字节流写入文件或者文件描述当中
FileWriter：用来写入字符输出流到指定文件
Files:最终类，只包含对文件、目录或其他类型文件进行操作的静态方法

---

BufferedInputStream、BufferedOutputStream、FileInputStream、FileOutputStream的使用代码示例

package com.wangxiaofei.io;
import static org.junit.Assert.*;
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 org.junit.Test;
public class BufferedInputStreamTest {
    private static final String FILE_PATH="D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/";
    @Test
    public void test() throws IOException {
        //声明字节流
        FileInputStream fis=null;
        FileOutputStream fos=null;
        //声明字节缓冲流
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        //声明文件
        File file=null;
        try {
          //读取源文件
          fis=new FileInputStream(FILE_PATH+"Faded.mp3");
          //写入文件
          file=new File(FILE_PATH+"out-faded.mp3");
          if(!file.exists()){
              file.createNewFile();
          }
          fos=new FileOutputStream(file);
          //创建字节输入输出缓冲流对象
          bis=new BufferedInputStream(fis);
          bos=new BufferedOutputStream(fos);
          //每次读取写入字节的大小
          byte[] bys=new byte[1024];
          int len=0;
          try {
            long start=System.currentTimeMillis();
            while((len=bis.read(bys))!=-1){
               bos.write(bys, 0, len);
            }
            long end=System.currentTimeMillis();
            System.out.println("总耗时："+(end-start));
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            System.out.println("找不到文件");
            e.printStackTrace();
        }finally{
            if(null!=bis) bis.close();
            if(null!=bos) bos.close();
        }   
    }
}

BufferedReader、BufferedWriter、FileReader、FileWriter代码示例如下：

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import org.junit.Test;
public class BufferedWriterTest {
    /**
     * BufferedWriter:字符输出缓冲流，搞效地将字符、字符数组、字符串写入文本
     * 构造方法：
     * BufferedWriter(Writer writer):创建一个字符输出缓冲流，使用默认大小缓冲区。
     * BufferedWriter(Writer writer,int size):创建一个字符输出缓冲流，指定缓冲区的大小。
     * 常用方法：
     * void close():关闭流。
     * void flush():刷新流。
     * void newLine():写入一行分隔符(换行)
     * void write(char[] cbuf, int off, int len):从字符数组写入一部分字符，off-从哪里开始，len-需要几个。
     * void write(int c):写入单个字符。
     * void write(String s, int off, int len):从字符串中写入一部分字符，off-从哪里开始，len-需要几个。
     * @throws IOException 
     */
    //任务1：将字符、字符数组的一部分、字符串的一部分写入test.txt文件中 
    @Test
    public void test1() throws IOException {
        char c='t';
        char[] charArray={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','k','r','s','t','u','v','w','x','y','z'};
        String str="ABCDEFGHIJKLMNOPQRSTUVWSYZ";
        //创建一个文件对象，用于输出。
        File file=new File("D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/test.txt");
        //判断该文件是否存在，不存在则创建
        if(!file.exists()){
            file.createNewFile();
        }
        //创建文件字符输出流对象
        FileWriter fw=new FileWriter(file);
        //创建字符输出流的缓冲对象
        BufferedWriter bw=new BufferedWriter(fw);
        //将字符、字符数组的一部分、字符串的一部分写入test.txt文件中 
        bw.write(c);
        bw.flush();
        bw.newLine();//换行
        bw.write(charArray, 0, 5);
        bw.flush();
        bw.newLine();//换行
        bw.write(str, 5, 10);
        bw.flush();
        bw.newLine();//换行
        bw.close();
    }

    //任务2：将note.txt的内容写入到test.txt中
    @Test
    public void test2() throws Exception{
      //创建文件对象
      File sourceFile=new File("D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/note.txt");
      if(!sourceFile.exists()) throw new Exception("源文件不存在");
      //创建字符缓冲输入流
      //BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream(sourceFile)))
      BufferedReader br=new BufferedReader(new FileReader(sourceFile));
      //创建目标文件
      File destinationFile=new File("D:/Workspaces/MyEclipse Professional 2014/JAVASECode/src/com/wangxiaofei/io/test.txt");
      if(!destinationFile.exists()){
          destinationFile.createNewFile();
      }
      //创建字符缓冲输出流
      BufferedWriter bw=new BufferedWriter(new FileWriter(destinationFile));
      String str=null;
      //将源文件的内容写入到目标文件中
      while((str=br.readLine())!=null){
          bw.write(str);
          bw.newLine();
          bw.flush();
      }
      br.close();
      bw.close();
    }
}

ByteArrayInputStream代码示例如下：

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.ByteArrayInputStream;
import org.junit.Test;
public class ByteArrayInputStreamTest {
    // 对应英文字母“abcddefghijklmnopqrsttuvwxyz”
    private static final byte[] byteArray={
        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
    };
    /**
     * ByteArrayInputStream:字节缓冲输入流
     * @throws Exception 
     */
    @Test
    public void test() throws Exception {
        //创建ByteArrayInputStream对象
        ByteArrayInputStream bais=new ByteArrayInputStream(byteArray);
        //在字节数组流中读取5个字节,并以字符串的形式输出。
        for(int i=0;i<5;i++){
            //是否可读
            if(bais.available()>0){
                System.out.println("第"+i+"个字节："+(char)bais.read());
            }
        }
        //判断是否有标记功能，没有则上报异常。
        if(!bais.markSupported()) throw new Exception("ByteArrayInputStream标记功能不可用");
        bais.mark(0);
        //跳过5个字节后再往后读取5个字节，以字符的形式输出
        bais.skip(5);
        byte[] temArray=new byte[5];
        bais.read(temArray, 0, 5);//从当前位置开始读取，读取长度为5
        for(byte bys:temArray){
            System.out.print((char)bys+" ");
        }
        System.out.println();
        //重置后输出标记位置上的后5个字节，以字符的形式输出。
        bais.reset();
        bais.read(temArray, 0, 5);
        for(byte bys:temArray){
            System.out.print((char)bys+" ");
        }
    }
}

ByteArrayOutputStream示例代码如下：

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.ByteArrayOutputStream;
import org.junit.Test;
public class ByteArrayOutputStreamTest {
    @Test
    public void test() {
      ByteArrayOutputStream bios=new ByteArrayOutputStream();
      //写入字节数据
      for(int i=0;i<5;i++){
          bios.write(101+i);
      }
      //转换字节数组
      byte[] bys=bios.toByteArray();
      for(byte b:bys){
          System.out.println((char)b);
      }
    }
}

CharArrayReader代码示例如下：

package com.wangxiaofei.io;
import static org.junit.Assert.*;
import java.io.CharArrayReader;
import java.io.IOException;
import org.junit.Test;
public class CharArrayReaderTest {
    //定义字符数组
    private static final char[] arr={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','k','r','s','t','u','v','w','x','y','z'};
    @Test
    public void test() throws IOException {
        //1、创建字符缓冲输入流
        CharArrayReader car=new CharArrayReader(arr);
        //2、读取5个字符
        for(int i=0;i<5;i++){
            //是否开始读取
            if(car.ready()){
                //是否支持标记功能
              if(!car.markSupported()){
                  return;
              }else{
                  //需要进行强转
                  char temp=(char)car.read();
                  System.out.println("第"+(i+1)+"个字符："+temp);
              } 
            }
        }
        //3、标记已经读取的位置
        car.mark(0);//下一次读取字符从f字符开始
        //4、跳过5个字符后读取后5个字符的串
        car.skip(5);//下一个字符从K位置开始读
        char[] char5=new char[5];
        car.read(char5, 0, 5);
        //String.valueOf(char[] c):将字符数组转换为字符串值
        System.out.println("继跳过5个字符后读取的字符为："+String.valueOf(char5));
        //5、重置字符流，到被标记的位置，继续读取5个字符
        car.reset();
        char[] makerlast=new char[5];
        car.read(makerlast, 0, 5);
        System.out.println("从标记开始读5个字符:"+String.valueOf(makerlast));
        //关闭流
        car.close();
    }
}

CharArrayWriter示例代码如下：

package com.wangxiaofei.io;
import java.io.CharArrayWriter;
import java.io.IOException;
import org.junit.Test;
public class CharArrayWriterTest {
    //定义字符数组
    private static final char[] arr={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','k','r','s','t','u','v','w','x','y','z'};
    @Test
    public void test() throws IOException {
      //1、创建字符输出流
      CharArrayWriter caw=new CharArrayWriter();
      //2、写入字符A后写入串AB
      caw.write('A');
      caw.write("AB");
      //3、从arr中读取defgh并写入
      caw.write(arr, 3, 8);
      System.out.println("输出流内容为："+caw);
      //4、写入字符0后写入123456789
      caw.write("0");
      caw.write("123456789");
      //5、从arr中读取ijkl并写入
      caw.write(arr,8,12);
      System.out.println("输出流内容为:"+caw);
      //6、计算输出流中字符的长度
      int size=caw.size();
      System.out.println("输出流内容长度为："+size);
      //7、转换成字符数组
      char[] c=caw.toCharArray();
      System.out.println(c[c.length-1]);
      System.out.println("转换后的字符数组："+String.valueOf(c));
      //8、将该字符输出流写入另一个字符输出流中
      CharArrayWriter caw2=new CharArrayWriter();
      caw.writeTo(caw2);
      System.out.println("caw2的字符流内容："+caw2);
      //关闭流
      caw.close();
      caw2.close(); 
    }
}