輸入輸出流

你的镁偷走了我的锌發表於2024-10-19

一、輸入輸出流介紹

IO流【輸入輸出流】：
        按照流向劃分：
            輸入流：外部資料 -> java程式
            輸出流：java程式 -> 外部資料

        按照資料型別劃分【根據使用記事本開啟是否能夠看懂來決定】：
            位元組流【萬能流】：
                位元組輸出流：
                    OutputStream（抽象類）
                        - FileOutputStream（實現子類）

                位元組輸入流：
                    InputStream（抽象類）
                        - FileInputStream（實現子類）
            字元流【記事本能看懂】：
                字元輸入流：
                字元輸出流：

        FileInputStream：
            構造方法：
                FileInputStream(File file)
                FileInputStream(String name)
            成員方法：
                public int read()
                public int read(byte[] b)

二、位元組輸入流

public class FileInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
//        FileInputStream fis = new FileInputStream(new File("java/src/com/shujia/day16/a1.txt"));
        FileInputStream fis = new FileInputStream("java/src/com/shujia/day16/a1.txt");

        //public int read() 一次只讀取一個位元組
        // 如果沒有讀到資料，返回-1
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        System.out.print((char)fis.read());
//        int i = 0;
//        while ((i = fis.read()) != -1) {
//            System.out.print((char) i);
//        }

        //public int read(byte[] b) 一次讀取一個位元組陣列
        //建立一個位元組陣列，用作接收讀取到的位元組
        byte[] bytes = new byte[7];
        int length = 0;
        while ((length = fis.read(bytes))!=-1){
            //讀取到的位元組在位元組陣列中
            //返回的是實際讀取到的位元組數
            //將位元組陣列轉字串
            String s = new String(bytes,0,length);
            System.out.print(s);
        }




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

使用位元組輸入流讀取檔案內容

import java.io.FileInputStream;

/*
    使用位元組輸入流讀取漢字
 */
public class FileInputStreamDemo2 {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("java/src/com/shujia/day16/a2.txt");

        // 一次讀取一個位元組
        System.out.println((char) fis.read());

        //一次讀取一個位元組陣列
//        byte[] bytes = new byte[1024];
//        int length = fis.read(bytes);
//        String s = new String(bytes, 0, length);
//        System.out.println(s);


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

三、位元組輸出流

import java.io.File;
import java.io.FileOutputStream;

/*
    IO流【輸入輸出流】：
        按照流向劃分：
            輸入流：外部資料 -> java程式
            輸出流：java程式 -> 外部資料

        按照資料型別劃分【根據使用記事本開啟是否能夠看懂來決定】：
            位元組流【萬能流】：
                位元組輸出流：
                    OutputStream（抽象類）
                        - FileOutputStream（實現子類）

                位元組輸入流：
                    InputStream（抽象類）
            字元流【記事本能看懂】：
                字元輸入流：
                字元輸出流：


      FileOutputStream：
        構造方法：
            FileOutputStream(File file)
            FileOutputStream(String name)

 */
public class FileOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        // FileOutputStream(File file) 將目標檔案封裝成File物件
        // 若目標檔案不存在，則會自動建立
//        FileOutputStream fos = new FileOutputStream(new File("java/src/com/shujia/day16/a1.txt"));

        //FileOutputStream(String name)
        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");


    }
}

向檔案中寫入資料

import java.io.FileOutputStream;

/*
    public void write(int b)
    public void write(byte[] b)
    public void write(byte[] b,int off,int len)


   思考：
        1、如何實現檔案內容追加寫？ 使用另一個過載的構造方法傳入append引數值
        2、如何實現寫的時候換行？寫一個換行符

 */
public class FileOutputStreamDemo2 {
    public static void main(String[] args) throws Exception{
//        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt");
        //public FileOutputStream(String name, boolean append)
        FileOutputStream fos = new FileOutputStream("java/src/com/shujia/day16/a1.txt", true);

        //public void write(int b) 寫一個ASCII碼值
//        fos.write(97);

        // public void write(byte[] b) 寫一個位元組陣列到檔案中
//        byte[] bytes = {97,98,99,100,101,102};
//        fos.write(bytes);


        //public void write(byte[] b,int index,int len)
//        fos.write(bytes,2,3);

        fos.write("\r\n".getBytes());
        fos.write("李剛真帥！".getBytes());

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

四、位元組緩衝輸入流

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/*
    InputStream:
        FileInputStream【普通的位元組輸入流】:
        BufferedInputStream【位元組緩衝輸入流】:
 */
public class BufferedInputStreamDemo1 {
    public static void main(String[] args) throws Exception {
        //BufferedInputStream(InputStream in)
        //建立一個 BufferedInputStream並儲存其引數，輸入流 in ，供以後使用。
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java/src/com/shujia/day16/a1.txt"));

        // 一次讀一個位元組
//        int i = 0;
//        while ((i=bis.read())!=-1){
//            System.out.print((char) i);
//        }

        // 一次都一個位元組陣列
        byte[] bytes = new byte[1024];
        int length = 0;
        while ((length = bis.read(bytes)) != -1) {
            String s = new String(bytes, 0, length);
            System.out.print(s);
        }


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

五、位元組緩衝輸出流

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/*
    OutputStream:
        FileOutputStream【普通的位元組輸出流】：
        BufferedOutputStream【位元組緩衝輸出流】：
 */
public class BufferedOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        //BufferedOutputStream(OutputStream out)
        //建立一個新的緩衝輸出流，以將資料寫入指定的底層輸出流。
        //建立一個位元組緩衝輸出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("java/src/com/shujia/day16/a2.txt"));

        bos.write("李剛是世界上最帥的男人！".getBytes());
        bos.write("好好學習".getBytes());
        bos.flush();



        //釋放資源
        bos.close(); // 關閉緩衝流的時候，會先將記憶體中的資料刷到磁碟中
    }
}

六、字元輸入流

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

/*
        字元流：
        字元輸入流：
            Reader【抽象類】
                - InputStreamReader【具體實現子類】
        字元輸出流：
            Writer【抽象類】
                - OutputStreamWriter【具體實現子類】

       InputStreamReader：
            構造方法：
                InputStreamReader(InputStream in) 建立一個使用預設字符集的InputStreamReader。
                InputStreamReader(InputStream in, String charsetName) 建立一個使用命名字符集的InputStreamReader。
            成員方法：
                public int read()
                public int read(char[] cbuf)

 */
public class InputStreamReaderDemo1 {
    public static void main(String[] args) throws Exception {
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/a3.txt"));
        //InputStreamReader(InputStream in, String charsetName)
        InputStreamReader isr = new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/a3.txt"), "GBK");


        // public int read() 一次都一個字元
//        System.out.print((char) isr.read());
//        System.out.print((char) isr.read());
//        int i = 0;
//        while ((i = isr.read()) != -1) {
//            System.out.print((char) i);
//        }

        //public int read(char[] cbuf) 一次讀取一個字元陣列
        char[] chars = new char[1024];
        int length = 0;
        while ((length= isr.read(chars))!=-1){
            String s = new String(chars, 0, length);
            System.out.print(s);
        }


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

七、字元輸出流

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.util.Arrays;

/*
    字元流【轉換流】：位元組流 + 編碼表

    編碼：加密
    解碼：解密

    字元流：
        字元輸入流：
            Reader
        字元輸出流：
            Writer【抽象類】
                - OutputStreamWriter【具體實現子類】

    OutputStreamWriter：
        構造方法：
            OutputStreamWriter(OutputStream out) 建立一個使用預設字元編碼的OutputStreamWriter。
            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 OutputStreamWriterDemo1 {
    public static void main(String[] args) throws Exception{
//        String s1 = "今天下午放假，不上課！";
////        byte[] bytes = s1.getBytes();
//        byte[] bytes = s1.getBytes("GBK");
//        System.out.println(Arrays.toString(bytes));
//
//        String s = new String(bytes,"GBK");
//        System.out.println(s);

        // 建立OutputStreamWriter(OutputStream out)物件
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/a3.txt"),"GBK");

        // public void write(int c) 一次寫一個字元
//        osw.write(97);
//        osw.flush();

        //public void write(char[] cbuf) 一次寫一個字元陣列
//        char[] chars = {'我','愛','數','加'};
//        osw.write(chars);

        //public void write(char[] cbuf,int off,int len) 一次寫字元陣列的一部分
//        osw.write(chars,1,3);
//        osw.flush();

        //public void write(String str) 直接寫一個字串
//        osw.write("李剛是32期最帥的男人！");
//        osw.flush();

        //public void write(String str,int off,int len) 寫字串的一部分
//        osw.write("李剛是32期最帥的男人！",6,2);

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


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

    }
}

八、字元緩衝輸入流

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;

/*
     字元流：
        字元輸入流：
            Reader【抽象類】
                - InputStreamReader【具體實現子類】
                    - FileReader【繼承自InputStreamReader】
                - BufferedReader 【字元緩衝輸入流】

        字元輸出流：
            Writer【抽象類】
                - OutputStreamWriter【具體實現子類】
                    - FileWriter【繼承自OutputStreamWriter】
                - BufferedWriter【字元緩衝輸出流】


        BufferedReader 【字元緩衝輸入流】:
            構造方法：
                BufferedReader(Reader in) 建立使用預設大小的輸入緩衝區的緩衝字元輸入流。
            特殊功能：
                public String readLine() 一次讀取文字檔案內容的一行, 不會讀取換行符


 */
public class BufferedReaderDemo1 {
    public static void main(String[] args) throws Exception {
        //建立字元緩衝輸入流物件
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("java/src/com/shujia/day16/b3.txt")));
        BufferedReader br = new BufferedReader(new FileReader("java/src/com/shujia/day16/b3.txt"));

        //一次讀一個字元
//        int i = 0;
//        while ((i=br.read())!=-1){
//            System.out.print((char) i);
//        }

        //一次讀一個字元陣列
//        char[] chars = new char[1024];
//        int length = 0;
//        while ((length=br.read(chars))!=-1){
//            String s = new String(chars, 0, length);
//            System.out.print(s);
//        }

        //一次讀取一行資料
//        System.out.println(br.readLine());
//        System.out.println(br.readLine());
//        System.out.println(br.readLine());
//        System.out.println(br.readLine());
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

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

九、字元緩衝輸出流

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;

/*
     字元流：
        字元輸入流：
            Reader【抽象類】
                - InputStreamReader【具體實現子類】
                    - FileReader【繼承自InputStreamReader】
                - BufferedReader 【字元緩衝輸入流】

        字元輸出流：
            Writer【抽象類】
                - OutputStreamWriter【具體實現子類】
                    - FileWriter【繼承自OutputStreamWriter】
                - BufferedWriter【字元緩衝輸出流】

      BufferedWriter【字元緩衝輸出流】：
            構造方法：
                BufferedWriter(Writer out) 建立使用預設大小的輸出緩衝區的緩衝字元輸出流。
            特殊方法：
                newLine(); // 預設會自動根據當前的系統生成一個換行符

 */
public class BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception{
        //BufferedWriter(Writer out) 建立使用預設大小的輸出緩衝區的緩衝字元輸出流。
//        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("java/src/com/shujia/day16/b3.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter("java/src/com/shujia/day16/b3.txt"));

        bw.write("落霞與孤鶩齊飛");
//        bw.write("\r\n"); // 這裡的換行符需要根據將來執行的系統環境來設定
        bw.newLine(); // 預設會自動根據當前的系統生成一個換行符
        bw.write("秋水共長天一色");

        bw.flush();


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

相關文章