Java-IO(字元流)

阿新 • • 發佈：2022-04-10

OutputStreamWriter

字元流 = 位元組流 + 編碼表

字元輸出流：Writer --OutputStreamWriter
字元輸入流：Reader

構造方法

public OutputStreamWriter(OutputStream out)

public OutputStreamWriter(OutputStream out,String charsetName)

OutputStream的寫方法：

public void write(int c)

public void write(char[] cbuf)

public void write(char[] cbuf,int off,int len)

public void write(String str)

public void write(String str,int off,int len)

package com.bigdat.java.day25;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
        字元流= 位元組流 + 編碼表
        字元輸出流：Write -- OutputStreamWrite
        字元輸入流：

        OutputStreamWriter 的構造方法
                    public OutputStreamWriter(OutputStream out)
                    public OutputStreamWriter(OutputStream out,String charsetName)

        OutputStreamWriter的寫法
                    public void write(int c)
                    public void write(char[] cbuf)
                    public void write(char[] cbuf,int off,int len)
                    public void write(String str)
                    public void write(String str,int off,int len)
 */
public class OutputStreamWriteDemo1 {
    public static void main(String[] args) {
        //建立字元輸出流物件
        //方式一：
//        FileOutputStream fos = null;
//        OutputStreamWriter osw = null;
//        try {
//            fos = new FileOutputStream("D:\\out.txt");
//            osw = new OutputStreamWriter(fos);
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                osw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
        //由於方式一太過於繁瑣，可以使用方式二簡化
        OutputStreamWriter osw = null;
        try {
            //在檔案輸出流的路徑後面，加上 true 可以實現追加
            osw = new OutputStreamWriter(new FileOutputStream("D:\\out.txt",true));

            //開始呼叫方法向流中寫入資料
            //public void write(int c)
            osw.write(89);
            osw.write(84);
            osw.write(99);
            osw.write(123);


            //public void write(char[] cbuf)
            //向檔案中寫入字元陣列
            char[] chars = {'我','愛','中','國','!'};
            osw.write(chars);


            //public void write(char[] cbuf,int off,int len)
            //寫入字元陣列的一部分
            osw.write(chars, 2, 2);
            osw.write("\t\n");

            //public void write(String str)
            //可以直接寫入字串
            osw.write("我是阿濤，阿濤要加油。縱使身處低谷，更要仰望星空！！");

            //public void write(String str,int off,int len)
            //輸出一部分的字串長度
            osw.write("\t\n");
            osw.write("我是阿濤，阿濤要加油。縱使身處低谷，更要仰望星空！！",5,5);

            //呼叫flush方法後，可以將緩衝區中的資料刷到檔案中，並且字元輸出流物件不會關閉
            osw.flush();
            System.out.println("寫入完畢！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //釋放資源，
                //包含的重新整理操作，但是重新整理之後，流物件關閉，後續就無法在進行操作了
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

字元輸入流：Reader -- InputStreamReader

構造方法

InputStreamReader(InputStream in)建立一個使用預設字符集的InputStreamReader。

InputStreamReader(InputStream in, String charsetName)
建立一個使用命名字符集的InputStreamReader。

兩種讀資料的方式：

1、public int read()

2、public int read(char[] cbuf)

package com.bigdat.java.day25;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/*
    字元輸入流：Reader -- InputStreamReader
      InputStreamReader的構造方法：
            InputStreamReader(InputStream in)
                建立一個使用預設字符集的InputStreamReader。
            InputStreamReader(InputStream in, String charsetName)
                建立一個使用命名字符集的InputStreamReader。

        InputStreamReader讀取資料的兩種方式：
            1、public int read()
            2、public int read(char[] cbuf)
 */
public class InputStreamReaderDemo1 {
    public static void main(String[] args) {
        //建立字元輸入流
        //方式一
//        FileInputStream fim = null;
//        InputStreamReader isr = null;
//        try {
//            fim = new FileInputStream("D:\\out.txt");
//            isr = new InputStreamReader(fim);
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                isr.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
        //建立字元輸入流的方式二: (由於方式一太過於麻煩)
        InputStreamReader isr = null;
        try {
           isr = new InputStreamReader(new FileInputStream("D:\\out.txt"));

           //呼叫方法讀取資料
            //方式一：一次讀取一個字元   public int read()
//            int length = 0;
//            while ((length = isr.read()) != -1){
//                System.out.print((char)length);
//            }

            System.out.println("=====================================================");
            //方式二: 按照字元陣列來讀取  public int read(char[] cbuf)
            int len = 0;
            char[] chars = new char[1024];
            while((len = isr.read(chars)) != -1){
                System.out.println(new String(chars, 0,len));
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //釋放資源
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

FileWriter

我們知道字元轉換流是基於位元組流誕生的，
字元流 = 位元組流 + 編碼表
但是呢，我們在正常寫程式的過程中並沒有刻意地傳入編碼，而是使用java預設地編碼去操作
OutputStreamWriter = FileOutputStream + 編碼表（Unicode編碼）
InputStreamReader = FileIntputStream + 編碼表（Unicode編碼）

上面的過程中，在建立物件時，名字有點長，所以java提供了一個字元流的簡化寫法

字元輸出流：FileWriter

字元輸入流：FilerReader

public class FileWriteDemo1 {
    public static void main(String[] args) {
        //以前寫法
        //OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("D:\\out1.txt"));
        //現在寫法
        FileWriter fileWriter = null;
        try {
            //如果目標檔案不存在，就會自動建
            fileWriter = new FileWriter("D:\\out1.txt");

            //向 out1 中寫入資料、
            fileWriter.write("好像我從來都沒有把一件事情給做的很好！");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //釋放資源
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字元輸入流：FilerReade

package com.bigdat.java.day25;
import java.io.*;
public class FileReaderDemo1 {
    public static void main(String[] args) {
        //InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("D:\\out1.txt"));
        //簡化的寫法
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("D:\\out1.txt");

            //開始讀取資料
            //方式一： 單個字元的讀取
//            int len = 0;
//            while((len = fileReader.read()) != -1){
//                System.out.print((char)len);
//            }
            //方式二： 按照字元陣列進行讀取
            char[] chars = new char[1024];
            int length = 0;
            while((length = fileReader.read(chars)) != -1){
                String str = new String(chars,0,length);
                System.out.println(str);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //關閉資源
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

字元緩衝流輸出流 BufferedWriter

類比之前學習位元組流的時候有緩衝流存在，
字元流也有相對應的緩衝流

字元緩衝輸出流：BufferedWriter

字元緩衝輸入流：BufferedReader

構造方法

BufferedWriter(Writer out)
建立使用預設大小的輸出緩衝區的緩衝字元輸出流。

BufferedWriter(Writer out, int sz)
建立一個新的緩衝字元輸出流，使用給定大小的輸出緩衝區。

public class BufferedWriterDemo1 {
    public static void main(String[] args) {
        //繁瑣寫法
        // BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\out2.txt")));
        // 建立字元緩衝流輸出物件
        BufferedWriter bw = null;
        try {
             bw = new BufferedWriter(new FileWriter("D:\\out4.txt",true));

             //呼叫方法寫入資料
            bw.write("天上人間，有誰值得被歌頌！");
            bw.write("不是所有感情都會有始有終，");
            bw.write("\t\n");
            bw.write("不是所有的事情都有結果");
            bw.newLine();
            bw.write("也不是所有的結果都有對錯！！！");
            bw.newLine();

            System.out.println("資料錄入完畢！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //釋放資源
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字元緩衝輸入流 BufferedReader

public class BufferedReaderDemo1 {
    public static void main(String[] args) throws IOException {
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d.txt")));
        BufferedReader br = new BufferedReader(new FileReader("d.txt"));
        //一次讀一個字元
//        int ch = 0;
//        while ((ch=br.read())!=-1){
//            System.out.print((char) ch);
//        }
        System.out.println("===============================");
        //一次讀取一個字元陣列
        char[] chars = new char[1024];
        int length = 0;
        while ((length=br.read(chars))!=-1){
            String s = new String(chars, 0, length);
            System.out.println(s);
        }
        //釋放資源
        br.close();
    }
}

字元緩衝流特有的方法

BufferedWriter:
public void newLine() throws IOException寫一行行分隔符。
行分隔符字串由系統屬性line.separator定義，並不一定是單個換行符（'\ n'）字元。

BufferedReader:
public String readLine() throws IOException讀一行文字。
一行被視為由換行符（'\ n'），回車符（'\ r'）中的任何一個或隨後的換行符終止。

public class BufferedReaderDemo2 {
    public static void main(String[] args) {
           // reader();
           writer();
    }
    public static void reader(){
        //建立字元輸出流物件
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("D:\\out4.txt"));
            // 按行讀入資料
            String len = null;
            while((len = br.readLine()) != null){
                System.out.println(len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //釋放資源
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    public static void writer(){
        //建立字元輸出流
        BufferedWriter br = null;
        try {
           br = new BufferedWriter(new FileWriter("D:\\out4.txt", true));

           //向檔案中寫入資料
            br.newLine();
            br.write("在人間，有誰活著不像是一場煉獄。");
            System.out.println("資料寫入成功！！！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //關閉資源
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}