常用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(); 
    }
}