Java學習筆記之位元組緩沖流&字元流&IO流練習

0x00 概述

本文涉及Java知識點有位元組緩沖流，字元流。

0x01 位元組緩沖流

1.1 位元組緩沖流構造方法

位元組緩沖流介紹

　　　　BufferOutputStream：該類實作緩沖輸出流，通過設定這樣的輸出流，應用程式可以向底層輸出流寫入位元組，而不必為寫入的每個位元組頻繁調用系統底層

　　　　BufferInputStream: 建立BufferedInputStream将建立一個内部緩沖區數組，當從流中讀取或者跳過位元組時，内部緩沖區将根據需要從所包含的輸入流中重新填充，一次很多位元組

構造方法

示例

package BufferStreamDemo;

import java.io.*;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        // 位元組緩沖輸出流： BufferedOutputStream(OutputStream out)
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream
                ("C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferStreamDemo\\fos.txt"));

        // 寫資料
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());

        // 釋放資源
        bos.close();

        // 位元組緩沖輸入流 : BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream
                ("C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferStreamDemo\\fos.txt"));

        /*
        // 一次讀取一個位元組資料
        int by;
        while ((by = bis.read()) != -1) {
            System.out.println((char) by);
        }
        System.out.println("--------------");
         */

        // 一次讀取一個位元組數組的資料
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            System.out.println(new String(bys, 0, len));
        }

        bis.close();
    }
}

複制

1.2 位元組流複制視訊

需求：把 E:\itcast\位元組流複制圖檔.avi 複制到子產品目錄下的位元組流複制圖檔.avi
實作步驟：

　　　　根據資料源建立位元組輸入流對象

　　　　根據目的地建立位元組輸出流對象

　　　　讀寫資料，複制視訊

　　　　釋放資源

示例

package CopyVideoDemo;


import java.io.*;

public class CopyVideoDemo {
    public static void main(String[] args) throws IOException {
        // 記錄開始時間
        long startTime = System.currentTimeMillis();

        // 複制視訊
        // method1();
        // method2();
        // method3();
        method4();

        // 記錄結束時間
        long endtime = System.currentTimeMillis();
        System.out.println("共耗時：" + (endtime - startTime) + "毫秒");
    }

    // 位元組緩沖流一次讀寫一個位元組數組
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn.avi")
        );

        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn2.avi")
        );

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }

    // 位元組緩沖流一次讀寫一個位元組
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn.avi")
        );

        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn2.avi")
        );

        int by;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }

        bos.close();
        bis.close();
    }

    // 基本位元組流一次讀寫一個位元組數組
    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn.avi"
        );

        FileOutputStream fos = new FileOutputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn2.avi"
        );

        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }

        fos.close();
        fis.close();
    }

    // 基本位元組流一次讀寫一個位元組
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn.avi"
        );

        FileOutputStream fos = new FileOutputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyVideoDemo\\mn2.avi"
        );

        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        fos.close();
        fis.close();
    }
}

複制

0x02 字元流

2.1 為什麼會出現字元流

字元流介紹

　　　　由于位元組流操作中文不是特别的友善，是以Java提供了字元流

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

中文的位元組存儲方式

　　　　用位元組流複制文本檔案時，文本檔案也會有中文，但是沒有問題，原因是最終底層操作會自動進行位元組拼接成中文，如何識别是中文的呢？

　　　　漢字在存儲的時候，無論選擇哪種編碼存儲，第一個位元組都是負數

2.2 編碼表

什麼是字元集

　　　　是一個系統支援的所有字元的集合，包括各國家文字，标點符号，圖形符号，數字等

　　　　計算機要準确的存儲和識别各種字元集符号，就需要進行字元編碼，一套字元集必然至少有一套字元編碼，常見字元集有ASCII字元集，GBXXX字元集，Unicode字元集等

常見的字元集

ASCII字元集：

　　　　ASCII：是基于拉丁字母的一套電腦編碼系統，用于顯示現代英語，主要包括控制字元(Enter鍵、倒退、換行鍵等)和可顯示字元(英文大小寫字元、阿拉伯數字和西文符号)

　　　　基本的ASCII字元集，使用7位表示一個字元，共128字元。ASCII的擴充字元集使用8位表示一個字元，共256字元，友善支援歐洲常用字元

　　　　是一個系統支援的所有字元的集合，包括各國家文字、标點符号、圖形符号、數字等

GBXXX字元集：

　　　　GBK：最常用的中文碼表。是在GB2312标準基礎上的擴充規範，使用了雙位元組編碼方案，共收錄了

　　　　21003個漢字，完全相容GB2312标準，同時支援繁體漢字以及日韓漢字等

Unicode字元集：

　　　　UTF-8編碼：可以用來表示Unicode标準中任意字元，它是電子郵件、網頁及其他存儲或傳送文字的應用

　　　　中，優先采用的編碼。網際網路工程工作小組（IETF）要求所有網際網路協定都必須支援UTF-8編碼。它使用

　　　　一至四個位元組為每個字元編碼

編碼規則：

　　　　128個US-ASCII字元，隻需一個位元組編碼

　　　　拉丁文等字元，需要二個位元組編碼

　　　　大部分常用字（含中文），使用三個位元組編碼

　　　　其他極少使用的Unicode輔助字元，使用四位元組編碼

2.3 字元串中的編碼解碼

相關方法

示例

package StringDemo;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        // 定義一個字元串
        String s = "中國";

        // byte[] bys = s.getBytes();              // [-28, -72, -83, -27, -101, -67]
        // byte[] bys = s.getBytes("UTF-8");       // [-28, -72, -83, -27, -101, -67]
        byte[] bys = s.getBytes("GBK");          // [-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        // String ss = new String(bys);
        // String ss = new String(bys, "UTF-8");
        String ss = new String(bys, "GBK");
        System.out.println(ss);

    }
}

複制

2.4 字元流中的編碼解碼

字元流中和編碼解碼問題相關的兩個類

　　　　InputStreamReader：從位元組流到字元流的橋梁

　　　　　　它讀取位元組，并使用指定的編碼及将其解碼為字元

　　　　　　它使用的字元集可以由名稱指定，也可以被明确指定，或者可以接受平台的預設字元集

　　　　OutputStreamWriter：是從字元流到位元組流的橋梁，使用指定的編碼将寫入的字元編碼為位元組

　　　　　　它使用的字元集可以由名稱指定，也可以被明确指定，或者可以接受平台的預設字元集

構造方法

示例

package ConversionStreamDemo;

import java.io.*;

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        OutputStreamWriter osw  = new OutputStreamWriter(new FileOutputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\ConversionStreamDemo\\osw.txt")
        );

         */

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\ConversionStreamDemo\\osw.txt"
        ), "UTF-8");

        osw.write("中國");
        osw.close();

        /*
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\ConversionStreamDemo\\osw.txt"
        ));

         */

        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\ConversionStreamDemo\\osw.txt"
        ), "UTF-8");

        // 一次讀取一個字元資料
        int by;
        while ((by = isr.read()) != -1) {
            System.out.println((char) by);
        }
        isr.close();
    }
}

複制

2.5 字元流寫資料的5種方法

方法介紹

重新整理和關閉的方法

示例

package OutputStreamWriterDemo;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\OutputStreamWriterDemo\\fos.txt"
        ));

        // void write(int c)： 寫一個字元
        // osw.write(97);
        // osw.write(98);
        // osw.write(99);
        // osw.write(100);

        // void write(char[] cbuf) : 寫入一個字元數組
        // char[] chs = {'a', 'b', 'c', 'd'};
        // osw.write(chs);

        // void write(String str)
        // osw.write("abcdefg");

        // void write(String str, int off, int len): 寫一個字元串的一部分
        // osw.write("abcdefghijk", 0, "abcdefghijk".length());
        osw.write("abcdefghijk", 1,3);


        // 釋放資源
        osw.close();
    }
}

複制

2.6 字元流讀資料的2種方法

方法介紹

示例

package InputStreamReaderDemo;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\InputStreamReaderDemo\\isrJava.java"
        ));

        /*
        // int read(): 一次讀一個字元資料
        int ch;
        while ((ch = isr.read()) != -1) {
            System.out.println((char) ch);
        }

         */

        // int read(char[] cbuf): 一次讀取一個字元數組資料
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.println(new String(chs, 0, len));
        }

        // 釋放資源
        isr.close();
    }
}

複制

2.7 字元流複制Java檔案

需求：把子產品目錄下的“ConversionStreamDemo.java” 複制到子產品目錄下的“Copy.java”
實作步驟：

　　　　根據資料源建立字元輸入流對象

　　　　根據目的地建立字元輸出流對象

　　　　讀寫資料，複制檔案

　　　　釋放資源

示例

package CopyJavaDemo1;

import java.io.*;

public class CopyJavaDemo1 {
    public static void main(String[] args) throws IOException {
        // 根據資料源建立字元輸入流對象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyJavaDemo1\\isrJava.java"
        ));

        // 根據目的地建立字元輸出流對象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyJavaDemo1\\isrJava2.java"
        ));

        // 讀寫資料，複制檔案
        /*
        // 一次讀寫一個字元資料
        int ch;
        while ((ch = isr.read()) != -1) {
            osw.write(ch);
        }

         */

        // 一次讀寫一個字元數組資料
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            osw.write(chs, 0, len);
        }

        // 釋放資源
        osw.close();
        isr.close();
    }
}

複制

2.8 字元流複制Java檔案改進版

需求：使用字元流對象，把子產品目錄下的“ConversionStreamDemo.java” 複制到子產品目錄下的“Copy.java”
實作步驟：

　　　　根據資料源建立字元輸入流對象

　　　　根據目的地建立字元輸出流對象

　　　　讀寫資料，複制檔案

　　　　釋放資源

示例

package CopyJavaDemo2;

import java.io.FileWriter;
import java.io.IOException;
import java.io.FileReader;

public class CopyJavaDemo2 {
    public static void main(String[] args) throws IOException {
        // 根據資料源建立字元輸入流對象
        FileReader fr = new FileReader("C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyJavaDemo2\\isrJava.java");

        // 根據目的地建立字元輸出流對象
        FileWriter fw = new FileWriter("C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyJavaDemo2\\isrJava2.java");

        // 讀寫資料，複制檔案
        /*
        int ch;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
        }

         */

        char[] chs = new char[1024];
        int len;
        while ((len = fr.read(chs)) != -1) {
            fw.write(chs, 0, len);
        }

    }
}

複制

2.9 字元緩沖流

字元緩沖流介紹

BufferWriter：将文本寫入字元輸出流，緩沖字元，以提供單個字元，數組和字元串的高校寫入，可以指定緩沖區大小，或者可以接受預設大小，預設值足夠大，可用于大多數用途

BufferReader：從字元輸入流讀取文本，緩沖字元，以提供字元，數組和行的高效讀取，可以指定緩沖區大小，或者使用預設大小，預設值足夠大，可用于大多數用途

構造方法

示例

package BufferedStreamDemo;

import java.io.*;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        // BufferedWriter(write out)
        BufferedWriter bw = new BufferedWriter(new FileWriter(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferedStreamDemo\\bw.txt"
        ));

        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.close();

        // BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new FileReader(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferedStreamDemo\\bw.txt"
        ));

        // 一次讀取一個字元資料
        /*
        int ch;
        while ((ch = br.read()) != -1) {
            System.out.println((char) ch);
        }

         */

        // 一次讀取一個字元數組資料
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1) {
            System.out.println(new String(chs, 0, len));
        }

        br.close();
    }
}

複制

2.10 字元緩沖流複制Java檔案

需求：把子產品目錄下的ConversionStreamDemo.java 複制到子產品目錄下的 Copy.java
實作步驟：

　　　　根據資料源建立字元緩沖輸入流對象

　　　　根據目的地建立字元緩沖輸出流對象

　　　　讀寫資料，複制檔案，使用字元緩沖流特有功能實作

　　　　釋放資源

示例

package BufferedStreamDemo;

import java.io.*;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        // BufferedWriter(write out)
        BufferedWriter bw = new BufferedWriter(new FileWriter(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferedStreamDemo\\bw.txt"
        ));

        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.close();

        // BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new FileReader(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferedStreamDemo\\bw.txt"
        ));

        // 一次讀取一個字元資料
        /*
        int ch;
        while ((ch = br.read()) != -1) {
            System.out.println((char) ch);
        }

         */

        // 一次讀取一個字元數組資料
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1) {
            System.out.println(new String(chs, 0, len));
        }

        br.close();
    }
}

複制

2.11 字元緩沖流特有功能

方法介紹

BufferWriter

BufferReader

示例

package BufferedStreamDemo2;

import java.io.*;

public class BufferedStreamDemo2 {
    public static void main(String[] args) throws IOException {
        // 建立字元緩沖輸出流
        BufferedWriter bw = new BufferedWriter(new FileWriter(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferedStreamDemo2\\bw.txt"));

        // 寫入資料
        for(int i =0;i<10;i++){
            bw.write("hello"+i);
            // bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }

        // 釋放資源
        bw.close();

        // 建立字元緩沖輸入流
        BufferedReader br = new BufferedReader(new FileReader(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\BufferedStreamDemo2\\bw.txt"
        ));

        String line;
        while((line=br.readLine())!=null) {
            System.out.println(line);
        }

        br.close();
    }
}

複制

2.12 字元緩沖流特有功能複制Java檔案

需求：使用特有功能把子產品目錄下的ConversionStreamDemo.java 複制到子產品目錄下的 Copy.java
實作步驟：

　　　　根據資料源建立字元緩沖輸入流對象

　　　　根據目的地建立字元緩沖輸出流對象

　　　　讀寫資料，複制檔案，使用字元緩沖流特有功能實作

　　　　釋放資源

示例

package CopyJavaDemo3;

import java.io.*;

public class CopyJavaDemo3 {
    public static void main(String[] args) throws IOException {
        // 根據資料源建立字元緩沖輸入流對象
        BufferedReader br = new BufferedReader(new FileReader(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyJavaDemo3\\test.java"
        ));

        // 根據目的地建立字元緩沖輸出流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\CopyJavaDemo3\\test2.java"
        ));

        // 讀寫資料
        // 使用字元緩沖流特有功能實作
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //釋放資源
        bw.close();
        br.close();

    }
}

複制

2.13 IO流小結

位元組流

　　　　位元組流可以複制人意檔案類型，有4種方式一般采用位元組緩沖流一次讀寫一個位元組數組的方式

字元流

　　　　字元流隻能複制文本資料，有5鐘方式，一般采用字元緩沖流的特有功能

0x03 練習案例

3.1 集合到檔案

需求：把文本檔案中的資料讀取到集合中，并周遊集合，要求：檔案中每一行資料是一個集合元素
實作步驟

　　　　建立字元緩沖輸入流對象

　　　　建立ArrayList集合對象

　　　　調用字元緩沖輸入流對象的方法讀資料

示例

package Text2ArrayListDemo;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class Text2ArrayListDemo {
    public static void main(String[] args) throws IOException {
        // 建立啊字元緩沖輸入流
        BufferedReader br = new BufferedReader(new FileReader(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\Text2ArrayListDemo\\text2.txt"));

        // 建立ArrayList集合對象
        ArrayList<String> arr = new ArrayList<String>();

        // 調用字元緩沖輸入流對象的方法讀取資料
        String line;
        while ((line = br.readLine()) != null) {
            arr.add(line);
        }
        
        // 釋放資源
        br.close();

        // 周遊集合
        for(String s : arr){
            System.out.println(s);
        }
    }
}

複制

3.2 檔案到集合

需求：把ArrayList集合的字元串寫入到文本檔案，要求：每一個字元串元素作為檔案中的一行資料
實作步驟：

　　　　建立ArrayList集合

　　　　往集合中存儲字元串元素

　　　　建立字元緩沖輸出流對象

　　　　周遊集合，得到每一個字元串的資料

　　　　調用字元緩沖輸出流對象的方法寫資料

　　　　釋放資源

示例

package ArrayList2TextDemo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayList2TextDemo {
    public static void main(String[] args) throws IOException {
        // 建立ArrayList集合
        ArrayList<String> arr = new ArrayList<>();
        
        // 往集合内添加字元串元素
        arr.add("Alice");
        arr.add("Bob");
        arr.add("Charlie");
        arr.add("Dogie");

        // 建立字元緩沖輸出流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\ArrayList2TextDemo\\text2.txt"));

        // 周遊集合，得到每一個字元串資料
        for(String s: arr) {
            // 調用字元緩沖輸出流對象的方法寫入檔案
            bw.write(s);
            bw.newLine();
            bw.flush();
        }

        // 釋放資源
        bw.close();
    }
}

複制

3.3 點名器

案例需求：一個檔案記憶體儲了班級同學的姓名，每一個姓名占一行，要求通過程式實作随機點名

實作步驟：

　　　　建立字元緩沖輸入流對象

　　　　建立ArrayList集合對象

　　　　調用字元緩沖輸入流對象的方法讀資料

　　　　把讀取到的字元串資料存儲到集合中

　　　　釋放資源

　　　　使用Random産生一個随機數，随機數的範圍在[0, 集合的長度]

　　　　把第6步産生的随機數作為索引到ArrayList集合中擷取值

　　　　把第7步得到的資料輸出到控制台

示例

package RandomNameDemo;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

public class RandomNameDemo {
    public static void main(String[] args) throws IOException {
        // 建立字元緩沖輸入流對象
        BufferedReader br = new BufferedReader(new FileReader(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\RandomNameDemo\\name.txt"
        ));

        // 建立ArrayList集合對象
        ArrayList<String> arr = new ArrayList<>();

        // 調用字元緩沖流輸入流對象的方法讀取資料
        String line;
        while ((line = br.readLine()) != null) {
            // 把讀取到的字元串資料添加到集合中
            arr.add(line);
        }

        // 釋放資源
        br.close();

        // 使用Random産生一個随機數，随機數的範圍在: [0, 集合的長度]
        Random r = new Random();
        int index = r.nextInt(arr.size());

        // 把随機數作為索引去集合内擷取值
        String name = arr.get(index);

        System.out.println("幸運兒是：" + name);

    }
}

複制

3.4 集合到檔案改進版

案例需求：把ArrayList集合中的學生資料寫入到文本檔案中，要求：每一個學生對象的資料作為檔案中的一行資料，格式：學号，姓名，年齡，居住地
實作步驟：

　　　　定義學生類

　　　　建立ArrayList集合

　　　　建立學生對象

　　　　把學生對象添加到集合中

　　　　建立字元緩沖輸出流

　　　　周遊集合，得到每一個學生對象

　　　　把學生對象的資料拼接成指定格式的字元串

　　　　調用字元緩沖輸出流對象的方法寫資料

　　　　釋放資源

示例

package ArrayList2FileDemo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayList2FileDemo {
    public static void main(String[] args) throws IOException {
        // 建立ArrayList集合
        ArrayList<Student> arr = new ArrayList<>();

        // 建立學生對象
        Student s1 = new Student("001", "Alice", 13, "BJ");
        Student s2 = new Student("002", "Bob", 12, "SZ");
        Student s3 = new Student("003", "Charlie", 15, "GZ");
        Student s4 = new Student("004", "Doggie", 14, "NJ");

        arr.add(s1);
        arr.add(s2);
        arr.add(s3);
        arr.add(s4);

        // 建立字元緩沖輸出流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\ArrayList2FileDemo\\Student_Object.txt"
        ));

        // 周遊結合，擷取每一個學生對象
        for (Student s : arr) {
            // 把學生對象的資料拼接成指定格式的字元串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getSid()).append(", ").append(s.getName()).append(", ").append(s.getAge())
                    .append(", ").append(s.getAddress());

            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        // 釋放資源
        bw.close();

    }
}

複制

3.5 檔案到集合改進版

案例需求：把ArrayList集合中的學生資料寫入到文本檔案中，要求：每一個學生對象的資料作為檔案中的一行資料，格式：學号，姓名，年齡，居住地
實作步驟：

　　　　定義學生類

　　　　建立字元緩沖輸入流對象

　　　　建立ArrayList集合對象

　　　　調用字元緩沖輸入流對象的方法讀資料

　　　　把讀取到的字元串資料用split()進行分割，得到一個字元串數組

　　　　建立學生對象

　　　　把字元串數組中的每一個元素取出來對應的指派給學生對象的成員變量值

　　　　把學生對象添加到集合

　　　　釋放資源

　　　　周遊集合

示例

package ArrayList2FileDemo2;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayList2Demo2 {
    public static void main(String[] args) throws IOException {
        // 建立字元緩沖流輸入對象
        BufferedReader br = new BufferedReader(new FileReader(
                "C:\\Users\\119k\\IdeaProjects\\d18\\src\\ArrayList2FileDemo2\\Student_Object.txt"
        ));

        // 建立ArrayList集合對象
        ArrayList<Student> arr = new ArrayList<>();

        // 調用字元緩沖輸入流對象的方法讀資料
        String line;
        while ((line = br.readLine()) != null) {
            String[] strArr = line.split(", ");

            // 建立學生對象
            Student s = new Student();
            s.setSid(strArr[0]);
            s.setName(strArr[1]);
            s.setAge(Integer.parseInt(strArr[2]));
            s.setAddress(strArr[3]);

            // 把學生對象添加到集合
            arr.add(s);
        }

        // 釋放資源
        br.close();

        // 周遊集合
        for(Student s: arr) {
            System.out.println(s.getSid() + ", "+s.getName()+", " +s.getAge()+", "+s.getAddress());
        }
    }
}

複制

Java學習筆記之位元組緩沖流&amp;字元流&amp;IO流練習

0x00 概述

0x01 位元組緩沖流

1.1 位元組緩沖流構造方法

1.2 位元組流複制視訊

0x02 字元流

2.1 為什麼會出現字元流

2.2 編碼表

2.3 字元串中的編碼解碼

2.4 字元流中的編碼解碼

2.5 字元流寫資料的5種方法

2.6 字元流讀資料的2種方法

2.7 字元流複制Java檔案

2.8 字元流複制Java檔案改進版

2.9 字元緩沖流

2.10 字元緩沖流複制Java檔案

2.11 字元緩沖流特有功能

2.12 字元緩沖流特有功能複制Java檔案

2.13 IO流小結

0x03 練習案例

3.1 集合到檔案

3.2 檔案到集合

3.3 點名器

3.4 集合到檔案改進版

3.5 檔案到集合改進版

Java學習筆記之位元組緩沖流&字元流&IO流練習