Java中IO流有什么用

這篇文章主要為大家展示了“Java中IO流有什么用”，內容簡(jiǎn)而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領(lǐng)大家一起研究并學(xué)習一下“Java中IO流有什么用”這篇文章吧。

1、IO流

1.流和流的分類(lèi)

什么是IO流？

I：Input （輸入）

O: Ouput（輸出）

IO流的分類(lèi)？

有多種分類(lèi)方式:

• 一種方式是按照流的方向進(jìn)行分類(lèi):

以?xún)却孀鳛閰⒄瘴?/p>

往內存中去，叫做輸入(Input)?；蛘呓凶鲎x(Read) .

從內存中出來(lái)，叫做輸出(output)?；蛘呓凶鰧?xiě)(write) .

• 另一種方式是按照讀取藪據方式不同進(jìn)行分類(lèi):

• 有的流是按照字節的方式讀取數據，一次讀取1個(gè)字節byte，等同于一次讀取8個(gè)二進(jìn)制。

• 這種流是萬(wàn)能的，什么類(lèi)型的文件都可以讀取。包括:文本文件，圖片，聲音文件，視頻……

• 有的流是按照字符的方式讀取數據的，一次讀取一個(gè)字符，這種流是為了方便讀取普通文本文件而存在的，這種流不能讀取:圖片、聲音、視頻等文件。只能讀取純文本文件,連word文件都無(wú)法讀取

總結：流的分類(lèi)

輸入流、輸出流、字節流、字符流

Java IO流的四大家族

注意:

• 四個(gè)都是抽象類(lèi)。

• 所有流都是實(shí)現了java.io.Closeable接口，都是可關(guān)閉的

• 流是一個(gè)管道，是內存和硬盤(pán)之間的通道。用完后一定要關(guān)閉，不然會(huì )占用很多資源。

• 所有的輸出流都實(shí)現了java.io.Flushable接口，都是可刷新的

• 最終輸出后，一定要記得調用flush()方法。目的是將管道中剩余未輸出的數據強行輸出完（清空管道）

• 如果沒(méi)有flash()，可能會(huì )導致丟失數據

• 在java中只要”類(lèi)名”以strean結尾的都是字節流。以"Reader/writer"結尾的都是字符流

java.io包下需要掌握的流有16個(gè):

文件專(zhuān)屬:

java . io.FileInputstream

java.io.FileOutputstream

java.io.FileReader

java.io.Filewriter

轉換流:(將字節流轉換成字符流)

java . io . InputstreamReader

java . io. outputstreamWriter

緩沖流專(zhuān)屬:

java. io. BufferedReader

java.io.BufferedWriter

java.io. BufferedInputstream

java . io.Bufferedoutputstrean

數據流專(zhuān)屬:

java . io . DataInputstream

java .io. Dataoutputstrean

標準輸出流:

java . io . Printwriter

java . io . Printstream

對象專(zhuān)屬流:

java.io.ObjectInputstream

java.io.ObjectOutputstream

一下子看到這么多流。不用怕，只需要掌握一組的使用方法就可以了，使用其他的都是一樣，一通百通。

下面以萬(wàn)能的字節流（FileInputStream、FileOutputStream）來(lái)舉例說(shuō)明。

2.如何使用流

1、輸入流(讀文件):FileInputStream

方法一

使用FileInputStream的read()

步驟：

1、 創(chuàng )建流對象

new FileInputStream(參數)

參數可以是一個(gè)File類(lèi)、String字符串表示的文件路徑

2、使用流的方法對文件進(jìn)行讀

輸入流調用read()方法，每次從流中讀取一個(gè)數據字節。返回值是讀到的字節的ASCII值

讀取一個(gè)后，他會(huì )指向下一個(gè)字符，如果到達末尾。返回-1，可以用while()來(lái)實(shí)現。

3、關(guān)閉流

調用close()方法

實(shí)例：

package com.io.stream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestFileInputStream {
    //定義一個(gè)流對象
    private static FileInputStream fis;
    public static void main(String[] args) {
        try {
            //1、 創(chuàng  )建流對象.參數可以是一個(gè)File類(lèi)、String字符串表示的文件路徑
            fis = new FileInputStream("E:\\aaa.txt");//在e盤(pán)下有一個(gè)aaa.txt的文件夾，內容為（abcdefg）
            //2、使用流的方法對文件進(jìn)行讀
            while (true) {
                int read = fis.read();//注意這里返回的是int類(lèi)型，代表是字符的ASCII值
                if (read==-1) {//讀到最后會(huì )返回-1，退出條件
                    break;
                }
                System.out.println(read);
            }
        } catch (FileNotFoundException e) {//異常細?；?，不同異?？梢赃x擇不同的處理方式
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //3、關(guān)閉流
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/*輸出
97
98
99
100
101
102
103
*/

int read()

該方法因為每次都是只讀取一個(gè)字節，這樣內存和硬盤(pán)交互太頻繁 ，開(kāi)銷(xiāo)大且效率不高。一般不使用，但是要了解，這是基礎。

方法二

一般使用這種方法

使用read(byte[] b)

一次讀取最多 b.length 個(gè)字節，減少內存和硬盤(pán)交互，提高執行效率

該方法返回的是讀到的字節的數量

使用步驟：和前面只有第二步有些差別

byte[] b= new byte[3];

int readNum = fis.read(b);

解析

• 新建一個(gè)byte[]數組b，代表我們一次需要讀多少個(gè)字符。讀完這么多字符后，下次一讀是從當前讀到的位置開(kāi)始，和上面一樣

• 將byte數組b傳入read()方法中，返回一個(gè)我們byte數組的大小,此時(shí)readNum值為3

那么我們讀出來(lái)的數據在哪里呢。自然是存放在byte數組里。我們打印b數組看，發(fā)現b數組里存放的讀到的ascii值

細節：

因為數組的長(cháng)度是我們設定的。如果文件讀到最后，不一定剛好符合我們設定的長(cháng)度，最后一組的長(cháng)度只有小于或等于數組的長(cháng)度。如果小于它會(huì )返回剩余的字符的數量，讀不到返回-1，我們可以利用這個(gè)作為循環(huán)退出的條件。

另外一個(gè)，因為他的長(cháng)度小于b數組，那么它的值也是無(wú)法填滿(mǎn)b數組的，此時(shí)，它只更新b數組中前面的n個(gè)讀到的值，b數組后面的是上一個(gè)讀取時(shí)讀取到的值。

實(shí)例：

仍然讀取aaa.txt文件，內容為（abcdefg）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
public class TestFileInputStream2 {
    private static FileInputStream fis;
    public static void main(String[] args) {
        try {
            fis = new FileInputStream("IO流\\aaa.txt");
            //準備一個(gè)byte數組
            byte[] b= new byte[3];
            int readNum = 0;
            while (true) {
                //先進(jìn)行讀操作。
                readNum=fis.read(b);
                //判斷
                if (readNum == -1) {
                    break;
                }
                //將字符數組轉為String,后面兩個(gè)參數為起始位置，和長(cháng)度
                String str = new String(b, 0, readNum);
                System.out.println(str);
            }
            /*輸出
				abc
				def
				g
			*/
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //關(guān)閉流
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

其他常用的方法

int available()

返回流中還有多少個(gè)字符沒(méi)有讀。（相當于獲得文件讀到的位置到末尾字符的個(gè)數，如果沒(méi)開(kāi)始讀，返回文件中總字符的數量）

使用這個(gè)可以對一些比較小的(字符長(cháng)度)文件一次讀完，如果不超過(guò)byte數組的范圍的話(huà)

public class TestFileInputStream3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("IO流\\aaa.txt");
        byte[] bytes = new byte[fis.available()];//創(chuàng  )建一個(gè)和文件字符數量一樣大的byte數組，文件不能太大。
        fis.read(bytes);
        System.out.println(new String(bytes));//b轉為字符串，輸出abcdefg
    }
}

skip(long n)

顧名思義：從輸入流中跳過(guò)并丟棄 n 個(gè)字節的數據。

2、輸出流(寫(xiě)文件):FileOutputStream

和輸入的流程差不多，過(guò)程也基本相同

write(byte[] b)

注意：

• byte的范圍是-128~127，超過(guò)會(huì )報錯

• 寫(xiě)完之后，一定要刷新

• 如果當前路徑下文件已存在，會(huì )將原文件清空，再寫(xiě)入（慎用）。

• 如果它是一個(gè)目錄，而不是一個(gè)常規文件，會(huì )報錯。

• 或者該文件不存在，但無(wú)法創(chuàng )建它，會(huì )報錯。

• 如果當前路徑下文件不存在，會(huì )新建文件。

package com.io.stream.output;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * @Author cyh
 * @Date 2021/8/7 17:21
 */
public class Test1 {
    private static FileOutputStream fos;
    public static void main(String[] args) {
        try {
            //新建一個(gè)輸出流，參數是輸出的路徑，最后的為文件名。
            fos = new FileOutputStream("IO流\\bbb.txt");
            //新建一個(gè)byte數組，里面對應的是abcd的ascii值
            byte[] bytes = {97, 98, 99, 100,101,127}; //注意byte的范圍是-128~127
            //輸出流調用write方法寫(xiě)入byte數組，以文件形式保存到上面的路徑
            fos.write(bytes);
            //寫(xiě)完之后，一定要刷新
            fos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

追加寫(xiě)文件

想要追加寫(xiě)文件，則需要在新建流的的時(shí)候，加一個(gè)參數true。

表示將字節寫(xiě)入文件末尾處，而不是寫(xiě)入文件開(kāi)始處

//新建一個(gè)輸出流，參數是輸出的路徑，最后的為文件名。增加true表示開(kāi)啟追加寫(xiě)
fos = new FileOutputStream("IO流\\bbb.txt",true);

注意：和上面一樣，不一樣的點(diǎn)只是追加寫(xiě)。

write(byte[] b, int off, int len)

將指定 byte 數組中從偏移量 off 開(kāi)始的 len 個(gè)字節寫(xiě)入此文件輸出流.

意思就是，寫(xiě)入的內容為off~len。如果off是0，len是數組長(cháng)度，那就全部寫(xiě)入；如果off是數組長(cháng)度-1，len是數組長(cháng)度，那就只寫(xiě)入了一個(gè)字符

3.文件的拷貝

• 使用FileInputStream+FileOutputStream即可完成文件的拷貝

• 拷貝的過(guò)程應該是一邊讀、一邊寫(xiě)

• 使用上面的字節流拷貝文件的時(shí)候，文件類(lèi)型隨意，是萬(wàn)能的。什么文件都可以拷貝

實(shí)例

package com.io.stream.copy;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * @Author cyh
 * @Date 2021/8/7 17:53
 */
public class TestCopy {
    private static FileInputStream fis;
    private static FileOutputStream fos;
    public static void main(String[] args) {
        try {
            //創(chuàng  )建一個(gè)輸入流
            fis = new FileInputStream("D:\\edgeDownload\\VSCodeUserSetup-x64-1.55.0.exe");
            //創(chuàng  )建一個(gè)輸出流
            fos = new FileOutputStream("C:\\Users\\PC\\Desktop\\copy\\b\\VSCodeUserSetup-x64-1.55.0.exe");
            //核心，一邊讀、一邊寫(xiě)
            byte[] bytes = new byte[1024*1024];//1MB,一次最多拷貝1MB
            int readNum=0;
            while((readNum=fis.read(bytes))!=-1){
                fos.write(bytes,0,readNum);//將bytes全部寫(xiě)入
            }
            //刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //資源要分開(kāi)釋放，不然一個(gè)出錯會(huì )導致另一個(gè)無(wú)法釋放
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}