Java中最全最基礎(chǔ)的IO流概述和簡介案例分析

更新時間：2025年09月22日 10:18:08 作者：極客編程坊

Java IO流用于程序與外部設(shè)備的數(shù)據(jù)交互,分為字節(jié)流（InputStream/OutputStream）和字符流（Reader/Writer）,處理流（如緩沖流、對象流）增強功能,提供緩沖、序列化及編碼轉(zhuǎn)換,支持高效文件操作、網(wǎng)絡(luò)通信和國際化文本處理,感興趣的朋友跟隨小編一起看看吧

IO流簡介

IO是什么

Java中的IO流是用于處理數(shù)據(jù)輸入和輸出的核心機制。通過應(yīng)用IO流可以使Java程序能夠與外部世界（如磁盤文件、網(wǎng)絡(luò)、硬件設(shè)備等）進(jìn)行數(shù)據(jù)交互。IO流的全稱為輸入/輸出流（Input/Output Stream），它是Java編程語言中用于數(shù)據(jù)傳輸?shù)囊环N抽象模型。流可以被想象為數(shù)據(jù)的連續(xù)流動，就像水通過管道一樣，數(shù)據(jù)通過流從一個地方流向另一個地方。

應(yīng)用場景

IO流在Java開發(fā)中幾乎無處不在，任何涉及到數(shù)據(jù)讀寫的地方都會用到IO流。常見的應(yīng)用場景包括文件讀寫、網(wǎng)絡(luò)通信、數(shù)據(jù)持久化等

IO流的分類

IO流的分類可以從多個維度進(jìn)行理解

按流的方向：可以分為輸入流InputStream)和輸出流(FileOutputStream)
按流的功能：可以分為節(jié)點流和處理流
按數(shù)據(jù)處理單元：可以分為字節(jié)流(以字節(jié)讀寫為基本單位)和字符流（以字符讀寫為基本單位）

流的超類類型

在Java中，輸入輸出（IO）流的超類主要有兩類，分別對應(yīng)于字節(jié)流和字符流.

字節(jié)流（Byte Streams）

java.io.InputStream：所有字節(jié)輸入流的超類。定義了從源讀取字節(jié)的基本方法
java.io.OutputStream：所有字節(jié)輸出流的超類。定義了向目的地寫入字節(jié)的基本方法

字符流（Character Streams）

java.io.Reader：字符輸入流的超類,定義了從源讀取字符的基本方法
java.io.Writer：字符輸出流的超類,定義了向目的地寫入字符的基本方法

這些超類提供了基本的讀寫操作，而它們的子類則實現(xiàn)了特定的讀寫功能，例如從文件讀取、向網(wǎng)絡(luò)套接字寫入、數(shù)據(jù)的緩沖等。例如：

字節(jié)流的具體實現(xiàn)包括：
- FileInputStream和FileOutputStream：用于讀寫文件。
- BufferedInputStream和BufferedOutputStream：提供緩沖，從而提高讀寫效率。
- ObjectInputStream和ObjectOutputStream：用于對象的序列化和反序列化。
- …
字符流的具體實現(xiàn)包括：
- FileReader和FileWriter：用于讀寫文本文件。
- BufferedReader和BufferedWriter、PrintWriter：提供字符緩沖，提高讀寫效率。
- InputStreamReader和OutputStreamWriter：用于在字節(jié)流和字符流之間轉(zhuǎn)換。
- …
  這些類構(gòu)成了Java IO流的層次結(jié)構(gòu)，允許開發(fā)者根據(jù)不同的需求選擇合適的流類型來進(jìn)行數(shù)據(jù)的讀寫操作。

字節(jié)文件流應(yīng)用

簡介

文件流是用來連接我們的程序與文件之間的"管道",用來讀寫文件中的數(shù)據(jù)。

核心API

文件流是繼承自InputStream和OutputStream的流對象，其分類為：

文件輸入流java.io.FileInputStream:讀取文件數(shù)據(jù)的流
文件輸出流java.io.FileOutputStream:寫入文件數(shù)據(jù)的流

文件輸出流應(yīng)用

java.io.FileOutputStream輸出流對象用于向文件中寫入數(shù)據(jù)，對象構(gòu)建通常會借助如下兩個構(gòu)造方法：

FileOutputStream(String path)
創(chuàng)建文件輸出流對指定的path路徑表示的文件進(jìn)行寫操作，如果該文件不存在則將其創(chuàng)建出來

FileOutputStream(File file)
創(chuàng)建文件輸出流對指定的file對象表示的文件進(jìn)行寫操作，如果該文件不存在則將其創(chuàng)建出來

案例

package io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
//API(工具-用于解決什么問題，怎么解決問題)
public class FOSDemo01 {
    public static void main(String[] args) throws IOException {
        //1.構(gòu)建一個文件輸出流對象
        //1)創(chuàng)建文件對象
        File file=new File("jsd/2406/fos.dat");//jsd/2406/是目錄
        //2)獲取文件對象的目錄結(jié)構(gòu)
        File parent = file.getParentFile();//jsd/2406/
        System.out.println(parent);
        //3).假如目錄不存在則創(chuàng)建目錄mkdirs();
        if(!parent.exists()){//parent.exists()假如返回true表示存在
            parent.mkdirs();//創(chuàng)建多層目錄
            System.out.println("文件不存在，創(chuàng)建成功");
        }
        //4)創(chuàng)建文件輸出流對象(用于向文件寫數(shù)據(jù)-二進(jìn)制)
        //構(gòu)建對象方法1
        //FileOutputStream fos1=new FileOutputStream("jsd/2406/fos.dat");
        //構(gòu)建對象方法2
        FileOutputStream fos2=new FileOutputStream(file);
        //5)向文件中寫入數(shù)據(jù)
        fos2.write(3);//這里的3表示10進(jìn)制數(shù)據(jù),3的二進(jìn)制數(shù)據(jù)為 00000011
        //0001  1(10進(jìn)制)
        //0010  2
        //0011  3
        //0100  4
        //0101  5
        fos2.write(4);
        fos2.write(5);
        System.out.println("數(shù)據(jù)寫入OK");
        //6)釋放資源(關(guān)閉流對象)
        fos2.close();
    }
}

文件輸入流應(yīng)用

java.io.FileInputStream文件輸入流對象用于從文件中讀取數(shù)據(jù)，常用構(gòu)造方法有：

FileInputStream(String path)
基于給定的路徑對應(yīng)的文件創(chuàng)建文件輸入流

FileInputStream(File file)
基于給定的File對象所表示的文件創(chuàng)建文件輸入流

案例

package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * 自己實踐：
 * 構(gòu)建文件輸入流FileInputStream對象，并基于此對象
 * 從jsd/2406/fos.dat文件中讀數(shù)據(jù)到程序中并輸出。
 */
public class FISDemo01 {
    public static void main(String[] args) throws IOException {
        //1.構(gòu)建文件輸入流對象
        FileInputStream fis=new FileInputStream("jsd/2406/fos.dat");
        //2.讀取數(shù)據(jù)
        //int a = fis.read();//讀取一個字節(jié)
        //int b = fis.read();
        //int c = fis.read();
        //int d = fis.read();
        //System.out.println("a="+a+";b="+b+";c="+c+";d="+d);
        int n=0;
        while((n=fis.read())!=-1){
            System.out.println(n);
        }
        //3.關(guān)閉流對象(水龍頭有打開是不是也會有關(guān)閉，否則浪費資源)
        fis.close();//流對象關(guān)閉后會釋放內(nèi)存
    }
}

文件的復(fù)制實踐

復(fù)制文件的原理就是使用文件輸入流從原文件中陸續(xù)讀取出每一個字節(jié)，然后再使用文件輸出流將字節(jié)陸續(xù)寫入到另一個文件中完成的。
案例1

package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 實現(xiàn)文件復(fù)制
 * 將當(dāng)前目錄中的a.png文件復(fù)制一份出來生成一個b.png文件
 */
public class FileCopyDemo01 {
    public static void main(String[] args) throws IOException {
        //一、實現(xiàn)思路
        //1.讀文件內(nèi)容(a.png)
        //2.將讀取的內(nèi)容寫到b.png中
        //二、代碼實現(xiàn)
        //1.構(gòu)建文件輸入流、輸出流對象
        FileInputStream fis=
            new FileInputStream("a.png");//這個文件需要存在
        FileOutputStream fos=
            new FileOutputStream("b.png");//這個文件不存在會自動創(chuàng)建
        //2.讀寫數(shù)據(jù)(復(fù)制)
        int n=-1;
        while((n=fis.read())!=-1){//讀取數(shù)據(jù),n為讀到的數(shù)據(jù),-1表示讀取到文件尾
            fos.write(n);//將讀取的數(shù)據(jù)寫入到b.png文件中
        }
        //3.關(guān)閉流對象
        fis.close();
        fos.close();
    }
}

塊讀寫操作實踐

塊讀:一次性讀取一組字節(jié)的方式
InputStream中定義了塊讀的方法

int read(byte[] data)
一次性讀取給定字節(jié)數(shù)組總長度的字節(jié)量并存入到該數(shù)組中。
返回值為實際讀取到的字節(jié)數(shù)。如果返回值為-1表示本次沒有讀取到任何字節(jié)已經(jīng)是流的末尾了

塊寫:一次性寫出一組字節(jié)的方式
OutputStream中定義了塊寫的方法

void write(byte[] data)
一次性將給定數(shù)組中所有字節(jié)寫出
void write(byte[] data,int offset,int len)
一次性將data數(shù)組中從下標(biāo)offset處開始的連續(xù)len個字節(jié)一次性寫出

案例實現(xiàn)：文件復(fù)制

package io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 實現(xiàn)文件復(fù)制
 * 將當(dāng)前目錄中的a.png文件復(fù)制一份出來生成一個b.png文件
 */
public class FileCopyDemo02 {
    public static void main(String[] args) throws IOException {
        //一、實現(xiàn)思路
        //1.讀文件內(nèi)容(a.png)
        //2.將讀取的內(nèi)容寫到b.png中
        //二、代碼實現(xiàn)
        //1.構(gòu)建文件輸入流、輸出流對象
        FileInputStream fis=
            new FileInputStream("a.png");//這個文件需要存在
        FileOutputStream fos=
            new FileOutputStream("b.png");//這個文件不存在會自動創(chuàng)建
        //2.讀寫數(shù)據(jù)(復(fù)制)
        //2.1定義數(shù)組用于臨時存儲讀取到數(shù)據(jù)
        byte[] data=new byte[1024];//這里數(shù)組的大小是自定義
        //2.2循環(huán)讀取數(shù)據(jù)
        int length=-1;
        while((length=fis.read(data))!=-1){//這里數(shù)組大小是1024，所以最多一次讀取1024個字節(jié),length表示讀取的字節(jié)數(shù)
            fos.write(data,0,length);//讀了多少寫多少,0表示起始位置，length表示寫入的字節(jié)數(shù)
        }
        //3.關(guān)閉流對象
        fis.close();
        fos.close();
    }
}

文本數(shù)據(jù)操作

對于FileInputStream和FileOutputStream提供的方法只能讀寫字節(jié)數(shù)據(jù)，對于文本數(shù)據(jù)如何操作呢？
案例1：寫文本數(shù)據(jù)

package io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**
 * 文本數(shù)據(jù)的寫操作實現(xiàn)
 */
public class WriteStringDemo01 {
    public static void main(String[] args) throws IOException {
        String str = "我愛Java";
        //構(gòu)建文件輸出流對象
        FileOutputStream fos=new FileOutputStream("./f1.txt");
        //寫字符數(shù)據(jù)
        byte[] data=str.getBytes(StandardCharsets.UTF_8);
        fos.write(data);
        str="Hello Tedu";
        fos.write(str.getBytes(StandardCharsets.UTF_8));
        //釋放資源
        fos.close();
    }
}

案例2：讀文本數(shù)據(jù)

package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class ReadStringDemo01 {
    public static void main(String[] args) throws IOException {
        //1.構(gòu)建文件輸入流對象
        //方式1：
       // File file=new File("./f1.txt");
       // long size=file.length();
       // FileInputStream fis=new FileInputStream(file);
        //方式2：
        FileInputStream fis=new FileInputStream("./f1.txt");
        //2.讀取文件內(nèi)容(將數(shù)據(jù)讀取到字節(jié)數(shù)組中)
        //byte[] data=new byte[(int)size];
        byte[] data=new byte[fis.available()];//fis.available()獲取流中有效字節(jié)數(shù)
        int len=fis.read(data);
        //3.將字節(jié)數(shù)組內(nèi)容轉(zhuǎn)換為字符串并輸出
        String str=new String(data,0,len);
        System.out.println(str);
        //4.關(guān)閉流
        fis.close();
    }
}

字節(jié)緩沖流應(yīng)用

處理流

概述
處理流是Java IO流體系中的一類重要的流，它們是在已經(jīng)存在的流（稱為基礎(chǔ)流或節(jié)點流）之上構(gòu)建的，為這些流添加額外的功能，而不改變原流本身。處理流的主要目的是為了增強或改變流的行為，比如提供緩沖、轉(zhuǎn)換數(shù)據(jù)類型、序列化等等。
應(yīng)用特征
處理流的典型特征是它們自身并不直接連接到物理的輸入/輸出設(shè)備，而是“裝飾”在其他流之上，利用這些流進(jìn)行數(shù)據(jù)的讀寫，并在此基礎(chǔ)上提供附加服務(wù)。處理流的實例通常會把讀寫操作委托給底層的流，同時可能對數(shù)據(jù)進(jìn)行一些預(yù)處理或后處理。

處理流可以串聯(lián)使用，即一個處理流的輸出可以作為另一個處理流的輸入，形成流的鏈?zhǔn)浇Y(jié)構(gòu)。例如，可以先使用BufferedInputStream對FileInputStream進(jìn)行包裝，然后再用其它處理流包裝這個緩沖流。

字節(jié)緩沖流

Java中的緩沖流是一種處理流，有java.io.BufferedInputStream和BufferedOutputStream其作用就是加快讀寫效率，通常緩沖流的應(yīng)用最終要鏈接在低級流上。

緩沖字節(jié)輸出流
BufferedOutputStream(OutputStream out)
實例化一個緩沖字節(jié)輸出流并鏈接在指定的字節(jié)輸出流上。默認(rèn)緩沖區(qū)大小8kb(內(nèi)部維護(hù)的byte[] buf數(shù)組長度8192)
BufferedOutputStream(OutputStream out,int size)
實例化一個指定緩沖區(qū)大小的緩沖字節(jié)輸出流并鏈接在指定的字節(jié)輸出流上。
緩沖字節(jié)輸入流
BufferedInputStream(InputStream in)
實例化一個緩沖字節(jié)輸入流并鏈接在指定的字節(jié)輸入流上。默認(rèn)緩沖區(qū)大小8kb(內(nèi)部維護(hù)的byte[] buf數(shù)組長度8192)
BufferedInputStream(InputStream in,int size)
實例化一個指定緩沖區(qū)大小的緩沖字節(jié)輸入流并鏈接在指定的字節(jié)輸入流上。

應(yīng)用案例分析

package io;
import java.io.*;
/**
 * 基于緩沖流實現(xiàn)文件復(fù)制
 */
public class FileCopyDemo03 {
    public static void main(String[] args) throws IOException {
        //1.構(gòu)建輸入輸出流對象(緩沖流增強文件流)
        BufferedInputStream bis =
                new BufferedInputStream(//處理流(這個流對象內(nèi)置一個緩沖區(qū)-byte[])
                        new FileInputStream("./a.png"));//節(jié)點流
        BufferedOutputStream bos =
                new BufferedOutputStream(//處理流
                        new FileOutputStream("./c.png"));//節(jié)點流
        //2.讀寫數(shù)據(jù)(拷貝)
        byte[] data=new byte[16];
        int len;
        while ((len = bis.read(data)) != -1){
            bos.write(data,0,len);
        }
        bos.flush();//這里表示刷新緩沖區(qū)內(nèi)容到文件
        //3.關(guān)閉流對象(關(guān)閉外層流時，內(nèi)層流會自動關(guān)閉)
        bis.close();
        bos.close();
    }
}

對象流應(yīng)用實踐

簡介

Java中的對象流也是一種處理流，有java.io.ObjectInputStream和java.io.ObjectOutputStream兩個類型，用于實現(xiàn)對象的讀寫。也就是對象的序列化（把對象轉(zhuǎn)化為字節(jié)）和反序列化（把字節(jié)轉(zhuǎn)換為對象）。

ObjectOutputStream：用于將Java對象序列化為字節(jié)流，以便可以將對象寫入文件、網(wǎng)絡(luò)或其他任何形式的持久存儲中。
ObjectInputStream：用于從字節(jié)流中反序列化Java對象，即將字節(jié)流重新轉(zhuǎn)換為Java對象。

Serializable接口
為了能夠被序列化，一個對象所屬的類必須實現(xiàn)Serializable接口。Serializable是一個標(biāo)記接口，不包含任何方法，它的存在僅僅是為了標(biāo)識一個類是可序列化的。如果嘗試序列化一個沒有實現(xiàn)Serializable接口的類的對象，將會拋出NotSerializableException異常。

應(yīng)用案例分析

設(shè)計一個Message對象類型

package io;
import java.io.Serializable;
/**
 * 消息對象
 */
public class Message implements Serializable {
    //Serializable只起到一個標(biāo)識性作用
    //添加序列化id(序列化時類中沒有寫序列化id，系統(tǒng)也會基于類中的屬性和方法自動生成)
    //private static final long serialVersionUID=1L;
    //Idea自動生成序列化ID如何進(jìn)行配置?可以在大模型中去搜索
    private static final long serialVersionUID = 8725255648785219540L;
    /*消息id*/
    private Integer id;
    /**消息標(biāo)題，
     * 假如這個屬性不希望系列化，
     * 可以使用transient關(guān)鍵字修飾*/
    private transient String title;
    /**消息內(nèi)容*/
    private String content;
    //private Integer userId;
    //.....
    public Message() {}
    public Message(Integer id, String title, String content) {
        this.id=id;
        this.title=title;
        this.content=content;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    //alt+insert
    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}

對象序列化案例實現(xiàn)

package io;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
 * 對象流應(yīng)用
 */
public class ObjectOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        Message m1 = new Message(1, "傳奇老師病了",  "做了個小手術(shù)");
        //1.構(gòu)建流對象
        ObjectOutputStream oos =
                new ObjectOutputStream(
                                   new FileOutputStream("message.txt"));
        //2.寫對象(序列化)
        oos.writeObject(m1);
        System.out.println("序列化OK");
        //3.關(guān)閉流對象
        oos.close();
    }
}

對象反序列化案例實現(xiàn)

package io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
 * 將message.txt文件中的內(nèi)容進(jìn)行反序列化
*/
public class ObjectInputStreamDemo02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.創(chuàng)建流對象
        ObjectInputStream ois=
                  new ObjectInputStream(
                           newFileInputStream("message.txt"));
        //2.讀取對象(反序列化-先讀出來的是字節(jié)，然后將字節(jié)轉(zhuǎn)換對象)
        Message msg=(Message)ois.readObject();
        System.out.println(msg);
        //3.關(guān)閉資源
        ois.close();
    }
}

字符轉(zhuǎn)換流應(yīng)用

字符流

在Java中，字符流（Character Streams）是用于處理文本數(shù)據(jù)的一種流類型，其基類是java.io.Reader和java.io.Writer兩個抽象類。
應(yīng)用場景？
字符流廣泛應(yīng)用于讀寫文本文件，處理字符串，以及在網(wǎng)絡(luò)通信中傳輸文本數(shù)據(jù)。由于文本文件通常包含人類可讀的內(nèi)容，字符流可以確保正確處理各種字符集和編碼，從而避免亂碼問題。
為什么使用字符流？

編碼透明性：字符流允許你指定字符編碼，因此你可以讀寫使用不同編碼的文本文件，而不需要了解具體的編碼細(xì)節(jié)。
字符邊界處理：當(dāng)處理多字節(jié)編碼（如UTF-8）的字符時，字符流能確保每次讀寫的都是一個完整的字符，避免字節(jié)流中可能出現(xiàn)的字符截斷問題（這里其實是亂碼）

字符流超類

java.io.Writer 所有字符輸入流的超類
常用方法

void write(int c):寫出一個字符,寫出給定int值”低16”位表示的字符。
void write(char[] chs):將給定字符數(shù)組中所有字符寫出。
void write(String str):將給定的字符串寫出
void write(char[] chs,int offset,int len):將給定的字符數(shù)組中從offset處開始連續(xù)的len個字符寫出

java.io.Reader 所有字符輸出流的超類
常用方法

int read():讀取一個字符，返回的int值“低16”位有效。當(dāng)返回值為-1時表達(dá)流讀取到了末尾。
int read(char[] chs):從該流中讀取一個字符數(shù)組的length個字符并存入該數(shù)組，返回值為實際讀取到的字符量。當(dāng)返回值為-1時表達(dá)流讀取到了

字符轉(zhuǎn)換流應(yīng)用

在Java中，字符轉(zhuǎn)換流是Java I/O體系中的一類流，它們實現(xiàn)了字節(jié)流和字符流之間的轉(zhuǎn)換。這類流包括InputStreamReader和OutputStreamWriter兩個核心類。*
InputStreamReader是一個讀取字節(jié)并使用指定的字符集將其解碼為字符的Reader；OutputStreamWriter則是一個接收字符并使用指定的字符集將其編碼為字節(jié)的Writer。

應(yīng)用場景

當(dāng)你需要從字節(jié)流中讀取文本數(shù)據(jù)，并且想要控制使用的字符編碼時。
當(dāng)你需要將字符數(shù)據(jù)寫入到字節(jié)流中，并指定字符編碼時。
在網(wǎng)絡(luò)通信中，當(dāng)你發(fā)送或接收的數(shù)據(jù)是以字節(jié)形式存在，但你希望以字符形式處理時。

為什么用它？

編碼兼容性：不同的系統(tǒng)和文件可能使用不同的字符編碼，字符轉(zhuǎn)換流可以讓你指定編碼，從而正確解析或生成文本。
國際化支持：為了支持多種語言和字符集，字符轉(zhuǎn)換流提供了靈活的編碼選擇，這對于開發(fā)國際化應(yīng)用非常重要。
數(shù)據(jù)完整性：在處理多字節(jié)編碼的字符時，字節(jié)流可能會導(dǎo)致字符被錯誤地分割，而字符轉(zhuǎn)換流保證了字符的完整性和正確性。

應(yīng)用案例分析和實踐

OutputStreamWriter 應(yīng)用案例(字符輸出轉(zhuǎn)化流應(yīng)用)
兩個構(gòu)造方法：

OutputStreamWriter(OutputStream out,Charset cs)
基于給定的字節(jié)輸出流以及字符編碼創(chuàng)建OSW

OutputStreamWriter(OutputStream out)
該構(gòu)造方法會根據(jù)系統(tǒng)默認(rèn)字符集創(chuàng)建OSW

具體應(yīng)用：通過字符轉(zhuǎn)換流將一些字符串寫入到指定文件

package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
/**
 * 通過字符轉(zhuǎn)換流將一些字符串寫入到指定文件
 */
public class OutputStreamWriterDemo01 {
    public static void main(String[] args) throws IOException {
        //1.構(gòu)建字符轉(zhuǎn)換輸出流對象
        OutputStreamWriter osw =
                new OutputStreamWriter(
                        new FileOutputStream("./osw.txt"),
                              StandardCharsets.UTF_8);
        //2.寫數(shù)據(jù)(字符串)
        osw.write("你好");//這里不會自動換行
        osw.write("子千老師");
        System.out.println("數(shù)據(jù)寫出完畢");
        //3.關(guān)閉流對象
        osw.close();
    }
}

IntputStreamReader 應(yīng)用案例(字符輸入轉(zhuǎn)化流應(yīng)用)
構(gòu)造方法：

InputStreamWriter(InputStream in,Charset cs)
基于給定的字節(jié)輸入流以及字符編碼創(chuàng)建當(dāng)前轉(zhuǎn)換流

InputStreamWriter(InputStream in)
該構(gòu)造方法會根據(jù)系統(tǒng)默認(rèn)字符集創(chuàng)建當(dāng)前轉(zhuǎn)換流

具體應(yīng)用案例：基于字符轉(zhuǎn)換流從文件讀取字符數(shù)據(jù)

package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
/**
 * 基于字符轉(zhuǎn)換流從文件讀取字符數(shù)據(jù)
 */
public class InputStreamReaderDemo01 {
    public static void main(String[] args) throws IOException {
        //1.創(chuàng)建字符輸入轉(zhuǎn)換流對象
        InputStreamReader isr = new InputStreamReader(
                new FileInputStream("./osw.txt"), 
                          StandardCharsets.UTF_8);
        //2.讀數(shù)據(jù)
        int data=0;
        while((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //3.關(guān)閉流對象
        isr.close();
    }
}

字符緩沖流應(yīng)用

簡介

在Java中，字符緩沖流是用于提高讀寫性能的一對流，它們包括BufferedReader和BufferedWriter。這些流通過內(nèi)部緩存機制減少了對底層I/O設(shè)備的訪問頻率，從而提高了讀寫操作的效率。
在字符輸出緩沖流應(yīng)用時，通常會結(jié)合PrintWriter一起使用。這個對象可以一次寫一行，并且可以自帶刷新機制。

快速入門實現(xiàn)

案例1：PrintWriter 不同構(gòu)造方法應(yīng)用

package io;
import java.io.*;
/**
 * 打印流應(yīng)用
 */
public class PrintWriterDemo01 {
    public static void main(String[] args) throws FileNotFoundException {
        //1.構(gòu)建PrintWriter對象
        //方式1：需要手動刷新緩沖區(qū)或者關(guān)閉流
        PrintWriter pw=new PrintWriter("./pw.txt");
        //方式2：自動刷新,構(gòu)造方法中的true表示自動刷新
        //PrintWriter pw = new PrintWriter(
                //new FileOutputStream("./pw.txt"),true);
        //2.寫入數(shù)據(jù)
        pw.println("hello");
        pw.println("world");
        pw.println("Java");
        //3.關(guān)閉流對象
        pw.close();
    }
}

案例2：自己指定緩沖流

package io;
import java.io.*;
public class PrintWriterDemo02 {
    public static void main(String[] args) throws FileNotFoundException {
        //1.構(gòu)建打印流對象(裝飾模式)
        PrintWriter printWriter = new PrintWriter(
                new BufferedWriter(
                        new OutputStreamWriter(
                          new FileOutputStream("./pw.txt"，true))), true);
        //2.寫數(shù)據(jù)
        printWriter.println("hello");
        printWriter.println("Java");
        //3.關(guān)閉流對象
        printWriter.close();
    }
}

案例3：字符輸入緩沖流應(yīng)用

package io;
import java.io.*;
import java.nio.charset.StandardCharsets;
/**
 * 編寫一個程序，能從一個文件中讀取數(shù)據(jù)，一次讀取一行，并將讀取的內(nèi)容進(jìn)行輸出
 */
public class BufferedReaderDemo01 {
    public static void main(String[] args) throws IOException {
        //1.構(gòu)建BufferedReader對象
        BufferedReader br = new BufferedReader(
                   new InputStreamReader(
                           new FileInputStream("./src/main/java/io/FISDemo01.java"),
                           StandardCharsets.UTF_8));
        //2.循環(huán)讀取文件中數(shù)據(jù)，讀一行，輸出一行
        String line = null;
        while ((line = br.readLine()) != null) {//readLine用于讀取一行
            System.out.println(line);
        }
        //3.關(guān)閉流對象
        br.close();
    }
}

到此這篇關(guān)于Java中最全最基礎(chǔ)的IO流概述和簡介案例分析的文章就介紹到這了,更多相關(guān)java io流內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: