【轉載】J2SE知識點歸納筆記(七)---Java IO Part 3：基本字節流

J2SE知識點歸納筆記(七)---Java IO Part 3：基本字節流

注：本文轉載自coder-pig

原文鏈接：http://blog.csdn.net/coder_pig/article/details/45311943

聽說小豬去談戀愛了，很少有空寫博客了，祝福他。。。

本節引言:

在上一節中我們學習了控制檯輸入數據的方法以及對Java IO流體系圖進行了初步的瞭解,

在本節中我們針對性地學習一些基本字節流與字符流的使用~開始本節內容:

1.InputStream與OutputStream的相關方法:

首先要說一點的是:這兩個類是抽象類,通過子類來實現各種功能;

數據單位爲字節(1 byte = 8bit);下面是相關的方法:

1)InputStream的相關方法:

①public abstract int read( ):讀取一個byte的數據，返回值是高位補0的int類型值;

                                         若返回值=-1說明沒有讀取到任何字節讀取工作結束。

②public int read(byte b[ ]):讀取b.length個字節的數據放到b數組中。返回值是讀取的字節數。
                                 如果流位於文件末尾不在有數據可用,返回-1;等同於read(b,0,b.length)

③public int read(byte b[ ], int off, int len):從輸入流中最多讀取len個字節的數據,存放到偏移量爲off的b數組中,

                                 如果流位於文件末尾不在有數據可用,返回-1;

④public int available( ):返回輸入流中可以讀取的字節數

                                   ps:若輸入阻塞，當前線程將被掛起，如果InputStream對象調用這個方法的話，它只會返回0，

                                   這個方法必須由繼承InputStream類的子類對象調用纔有用

⑤public int close( ):使用完畢後,關閉流

⑥public long skip(long n):忽略輸入流中的n個字節,返回值是實際忽略的字節數,跳過一些字節來讀取

⑦public void mark(int readlimit):在此輸入流中標記當前位置,如果後續調用reset方法會在最後標記的位置重新定位

                                  此流,以便後續讀取重新讀取相同的字節,另外參數:readlimit代表:標記失效錢允許讀取的字節數

                                  ps:jdk 1.6後貌似沒限制多少個字節~

⑧public void reset( ):將流重新定位到最後一次調用mark方法的位置!

⑨public boolean markSupported( ):判斷該輸入流是否支持mark和reset方法

ps:這裏的mark和reset方法,你們可能不是很明白,後面學習BufferedInputStream的時候,

會給大家寫個例子,到時你就知道這兩個玩意的作用了...

還有,雖然read有三種不同的構造方法,但是建議使用後面兩個,第一個少用!!!

2)OutputStream的相關方法:

①public void close( ):關閉此輸出流並釋放與此流有關的所有系統資源

②public void flush( ):刷新此輸出流並強制寫出所有緩衝的輸出字節

③public abstract void write(int b):將指定的字節寫入此輸出流

④public void write(byte[] b):將 b.length個字節從指定的byte數組寫入此輸出流

⑤public void write(byte[] b,int off,int len):將指定 byte 數組中從偏移量 off 開始的 len 個字節寫入此輸出流

ps:其實這些方法,直接查文檔都可以查出來的,筆者也是貼的api上的解析而已~

    所以遇到不會用,沒見過的方法,先查文檔~

2.FileInputStream與FileOutputStream類的使用:

先來介紹字節流的第一個子類:ileInputStream與FileOutputStream類吧!

見名知意:就是以字節的形式對文件進行讀寫操作;

這裏就不貼相關方法了,自行查閱API文檔吧,直接上實例:

代碼實例:實現文件複製

/*
     * 該方法用於複製文件,是最簡單的,沒有加入緩衝機制,所以很垃圾~只是方便讀者理解
     * 參數以此是:被複制文件的完整路徑，以及複製後生成的文件的完整路徑
     * */
    public static void copyFile1(String file1,String file2) throws IOException
    {
        File file = new File(file1);
        File outfile = new File(file2);
        FileInputStream inputStream = new FileInputStream(file);
        FileOutputStream outputStream = new FileOutputStream(outfile);
        int i = 0;
        while(i != -1) {
            i = inputStream.read();
            outputStream.write(i);
        }
        //記得關閉流
        inputStream.close();
        outputStream.close();
    }

運行截圖:

好了,上述的代碼,如果複製的是大文件,就呵呵了,等死你...所以我們需要加入緩衝區,

以便提高文件的複製速度,就是添加一個字節緩衝數組而已~

代碼也很簡單:

/*
     * 該方法在1的基礎上,添加了byte[]數組緩衝機制,複製大文件的時候,他的優勢就顯現出來了~
     */
    public static void copyFile2(String file1, String file2) throws IOException {
        File file = new File(file1);
        File outfile = new File(file2);
        FileInputStream inputStream = new FileInputStream(file);
        FileOutputStream outputStream = new FileOutputStream(outfile);
        int i = 0;
        //設置緩衝的字節數組爲緩衝512 byte
        byte[] buffer = new byte[512];
        while (true) {
            if (inputStream.available() < 512) {
                while (i != -1) {
                    i = inputStream.read();
                    outputStream.write(i);
                }
                break;
            } else {
                // 當文件的大小大於512 byte時
                inputStream.read(buffer);
                outputStream.write(buffer);
            }
        }
        // 記得關閉流
        inputStream.close();
        outputStream.close();
    }

代碼解析:

就是添加一個512byte的字符數組,但是速度卻明顯提高了,不信麼?

你可以找個大文件試試,比如筆者這裏用的美圖秀秀,差不多30M,用1中的

方法,過了差不多1分多鐘才複製完畢,而用加了緩衝的幾秒鐘就複製好了~

3)ByteArrayInputStream與ByteArrayOutputStream類的使用:

見名知意:字節數組的字節流,創建實例是程序內部會創建一個byte型數組的緩衝區,

在網絡傳輸的時候用的比較多,這裏給獲得某個頁面的網頁源代碼~

ByteArrayOutputStream用得比較多,另外toByteArray( )方法很常用

你也可以自行擴展,比如,訪問的url是圖片,然後把圖片保存到本地~

代碼實例:

/*
     * 獲得某個網頁源代碼:
     * 參數是一個網頁的鏈接:
     * */
    public static String getHtml(String path)throws Exception
    {
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(5000);
        conn.setRequestMethod("GET");
        if(conn.getResponseCode() == 200)
        {
            InputStream in = conn.getInputStream();
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            while((len = in.read(buffer)) != -1)
            {
                out.write(buffer,0,len);
            }
            in.close();
            byte[] data = out.toByteArray();
            String html = new String(data,"UTF-8");
            return html;
        }
        return null;
    }

運行截圖：

好了,這樣就讀取到一個網頁的源代碼了~

4)ObjectInputStream與ObjectOutputStream類 

見名知意,對象字節流,就是可以直接把對象轉換爲流,另外,轉換的對象對應的類,

需要實現Serializable接口,另外對象中的transient和static類型成員變量不會被讀取和寫入

下面我們來寫個簡單的代碼示例:

step 1:定義一個業務Bean:

import java.io.Serializable;

public class Book implements Serializable {
    private String bName;
    private String bReporter;

    public Book(String bName, String bReporter) {
        super();
        this.bName = bName;
        this.bReporter = bReporter;
    }

    public String getbName() {
        return bName;
    }

    public void setbName(String bName) {
        this.bName = bName;
    }

    public String getbReporter() {
        return bReporter;
    }

    public void setbReporter(String bReporter) {
        this.bReporter = bReporter;
    }

}

step 2:先構造低級流FileOutputStream和FileInputStream,然後才能使用

ObjectOutputStream與ObjectInputStream:

public static void main(String[] args) throws Exception {
        Book b1 = new Book("《如何與傻B相處》", "豬小豬");
        Book b2 = new Book("《逗比的自我修養》", "貓小貓");
        Book b3,b4;
        //注意:使用高級流需要先構造低級流
        //①把對象直接寫入到文件中
        FileOutputStream fout = new FileOutputStream("D:/books.txt");
        ObjectOutputStream out = new ObjectOutputStream(fout);
        out.writeObject(b1);
        out.writeObject(b2);
        //關閉輸出流
        out.close();
        //②讀取文件中的對象:
        FileInputStream fin=new FileInputStream("D:/books.txt");
        ObjectInputStream in=new ObjectInputStream(fin);
        b3=(Book) in.readObject();
        b4=(Book) in.readObject();
        //關閉輸入流
        in.close();
        System.out.println(b3.getbName() + " 作者: "+ b3.getbReporter());
        System.out.println(b4.getbName() + " 作者: "+ b4.getbReporter());
    }

運行截圖：

同時,我們可以在D盤下看到這個book.txt的文件,但是打開後是亂碼,

這是因爲,我們寫入的是字節流~中文就會出現亂碼,如果想解決這種情況,

可以使用後面會說的FileWriter和FileReader~

5)PipedOutputStream與PipedInputStream類

這個是管道流,相比起前面的介紹的幾個流,這個就稍微複雜點了,

通過這兩個流可以讓多線程通過管道進行線程間的通訊,兩者需要搭配使用哦!

不同於Linux和Unix系統中的管道,他們是不同地址空間空間的兩個進程可以通過管道通信,

而Java中則是運行在同一進程中的不同線程!

原理:PipedInputStream內部有一個Buffer,使用InputStream的方法讀取其Buffer中的字節;

而Buffer中的字節是PipedOutputStream調用PipedInputStream的方法放入的;

另外,不建議把這兩個流對應的對象寫在同一線程中,不然很容易引起死鎖,

使用connect( )方法可以將這個管道搭建起來,再進行數據傳輸~

這裏找了個簡單的小例子給大家體會下吧~

1)SendThread.java:(輸出流)

import java.io.IOException;
import java.io.PipedOutputStream;


public class SendThread extends Thread{
    private PipedOutputStream out = new PipedOutputStream();
    public PipedOutputStream getOutputStream(){
        return out;
    }
    public void run(){
            String strInfo = "我是PipedOutputStream寫入的東西" ;
            try {
                out.write(strInfo.getBytes());
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
}

2)ReceiverThread.java:(輸入流)

import java.io.IOException;
import java.io.PipedInputStream;

public class ReceiverThread extends Thread {
    private PipedInputStream in = new PipedInputStream();

    public PipedInputStream getInputStream() {
        return in;
    }

    public void run() {
        byte[] buf = new byte[1024];
        try {
            int len = in.read(buf);
            System.out.println(new String(buf, 0, len));
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

測試類:Test5.java:

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Test5 {
    public static void main(String[] args) {
        ReceiverThread rThread = new ReceiverThread();
        SendThread sThread = new SendThread();
        // 獲取對應流:
        PipedOutputStream out = sThread.getOutputStream();
        PipedInputStream in = rThread.getInputStream();
        try {
            // 管道鏈接
            out.connect(in);
            sThread.start();
            rThread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

運行截圖:

6)SequenceInputStream合併流:

見名知意,就是合併多個輸入流.即當我們需要從多個輸入流中向程序讀入數據的時候可以考慮使用合併流,

SequenceInputStream會將與之相連接的流集組合成一個輸入流並從第一個輸入流開始讀取，

直到到達文件末尾，接着從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的文件末尾爲止；

合併流的作用是將多個源合併合一個源！

要注意的地方:(構造方法)

SequenceInputStream爲我們提供了兩個不同的構造方法:

1~SequenceInputStream(Enumeration<? extends InputStream> e) 

2~SequenceInputStream(InputStream s1, InputStream s2)

PS:這個Enumertaion是一個接口,Enumeration接口定義了從一個數據結構得到連續數據的手段

該接口提供的兩個方法:

boolean hasMoreElements():測試此枚舉是否包含更多的元素。 

nextElement( ):如果此枚舉對象至少還有一個可提供的元素,則返回此枚舉的下一個元素.

這裏並不詳細介紹Enumertaion了,想了解的自行查閱文檔~

那麼接下來我們來寫兩個簡單的小程序方便我們理解:

①使用兩個流作爲參數的構造方法:

public static void main(String[] args) throws IOException {
       InputStream s1 = new ByteArrayInputStream("ABC".getBytes());
       InputStream s2 = new ByteArrayInputStream("abc".getBytes());
       InputStream in = new SequenceInputStream(s1, s2);
       int data;
       while ((data = in.read()) != -1) {
           System.out.println(data);
       }
       in.close();
   }

運行結果:(對應ABCabc的ASCII碼值,別問我爲什麼不用漢字,因爲本節講的是字節流,一個漢字兩個字節~)

②使用Enumeration作爲參數的那個構造方法:

public static void main(String[] args) throws IOException {
         //創建合併流
        SequenceInputStream sin = null;
        //創建輸出流
        BufferedOutputStream bout = null;
        try {
            //構建流集合
            Vector<InputStream> vector = new Vector<InputStream>();
            vector.addElement(new FileInputStream("D:\\test1.txt"));
            vector.addElement(new FileInputStream("D:\\test2.txt"));
            vector.addElement(new FileInputStream("D:\\test3.txt"));
            vector.addElement(new FileInputStream("D:\\test4.txt"));
            Enumeration<InputStream> e = vector.elements();

            sin = new SequenceInputStream(e);
            bout = new BufferedOutputStream(
                    new FileOutputStream("D:\\textUnion.txt"));

            //讀寫數據
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = sin.read(buf)) != -1) {
                bout.write(buf, 0, len);
                bout.flush();
            }
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        } catch (IOException e1) {
            e1.printStackTrace();
        } finally {
            try {
                if (sin != null)
                    sin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bout != null)
                    bout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

接着我們在D盤目錄下創建:test1,test2,test3,test4四個txt文件,內容依次爲:

逗A,逗B,逗C,逗D

運行截圖:

會在D盤下生產testUnion.txt的文件,打開文件後可以看到:

最後說兩句:

好的,關於Java IO中的基本字節流就講到這裏了,現在我們來回顧下本節講解的東東:

①InputStream和OutputStream兩個父類的相關方法

②FileInputStream與FileOutputStream類文件讀寫類的使用,加入了緩衝數組提高了讀寫效率~

③ByteArrayInputStream與ByteArrayOutputStream類字節數組類,我們寫了個獲取網頁源碼的例子:

④ObjectInputStream與ObjectOutputStream類對象讀寫類,我們通過這兩個類可以很方便地完成

從對象到流,流到對象的轉化,另外要注意一點,這個對象所屬的類要繼承Serializable接口!

⑤PipedOutputStream與PipedInputStream類管道輸入輸出類,這兩個是用於線程間進行通信的,

一般避免把這兩個寫到同一個線程中,不然很容易引起死鎖,本節只是給出一個簡單的應用例子,後續有

需要再進行深入研究~

⑥SequenceInputStream合併流,就是可以將多個輸入流合併成一個輸入流,有兩種構造形式:

分別是兩個輸入流,或者一個Enumeration參數,也很簡單,大家看懂例子即可~

那麼,關於本節的基本字節流就到這裏,謝謝你的閱讀~

如果你覺得本文可以的話,可花1s點個贊,讓更多的朋友可以看到這篇文章~萬分感謝~