【Java基礎之五】Java中IO詳解

阿新 • • 發佈：2019-01-20

1.Java IO簡介

可能學過計算機組裝與維修的同學都知道I/O裝置，翻譯過來也就是Input/Output（輸入輸出裝置），在硬體中鍵盤、滑鼠屬於輸入裝置，顯示器、印表機等屬於輸出裝置，這裡輸入輸出參考物是計算機本身。
java.io包從巨集觀上來理解和硬體有些相同，Java中IO是以流為基礎進行輸入輸出的，所有資料被序列化寫入輸出流，或者從輸入流讀入。
流是一種有順序的，有起點和終點的位元組集合，是對資料傳輸的總成或抽象。即資料在兩裝置之間的傳輸稱之為流，流的本質是資料傳輸，根據資料傳輸的特性將流抽象為各種類，方便更直觀的進行資料操作。

2.Java IO使用場景

Java的IO包主要關注的是從原始資料來源的讀取以及輸出原始資料到目標媒介。以下是最典型的資料來源和目標媒介：

1.檔案

2.管道

3.網路連線

4.記憶體快取

5.System.in, System.out, System.error(注：Java標準輸入、輸出、錯誤輸出)

2.1 Java IO 的一般使用原則

2.1.1 按資料來源（去向）分類

1 、是檔案： FileInputStream, FileOutputStream, ( 位元組流 )FileReader, FileWriter( 字元 )

2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 位元組流 )

3 、是 Char[]: CharArrayReader, CharArrayWriter( 字元流 )

4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 位元組流 )StringReader, StringWriter( 字元流 )

5 、網路資料流： InputStream, OutputStream,( 位元組流 ) Reader, Writer( 字元流 )

2.1.2 按是否格式化輸出分

1 、要格式化輸出： PrintStream, PrintWriter

2.1.3 按是否要緩衝分

1 、要緩衝： BufferedInputStream, BufferedOutputStream,( 位元組流 ) BufferedReader, BufferedWriter( 字元流 )

2.1.4 按資料格式分

1 、二進位制格式（只要不能確定是純文字的） : InputStream, OutputStream 及其所有帶 Stream 結束的子類

2 、純文字格式（含純英文與漢字或其他編碼方式）； Reader, Writer 及其所有帶 Reader, Writer 的子類

2.1.5 按輸入輸出分

1 、輸入： Reader, InputStream 型別的子類

2 、輸出： Writer, OutputStream 型別的子類

2.1.6 特殊需要

1 、從 Stream 到 Reader,Writer 的轉換類： InputStreamReader, OutputStreamWriter

2 、物件輸入輸出： ObjectInputStream, ObjectOutputStream

3 、程序間通訊： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合併輸入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

決定使用哪個類以及它的構造程序的一般準則如下（不考慮特殊需要）：

首先，考慮最原始的資料格式是什麼：原則2.1.4

第二，是輸入還是輸出：原則2.1.5

第三，是否需要轉換流：原則2.1.6第1點

第四，資料來源（去向）是什麼：原則2.1.1

第五，是否要緩衝：原則2.1.3 （特別註明：一定要注意的是 readLine() 是否有定義，有什麼比 read, write 更特殊的輸入或輸出方法）

第六，是否要格式化輸出：原則2.1.2

3.Java IO分類

按資料處理方式分：位元組流 & 字元流
按資料起點終點分：輸入流 & 輸出流

關於類的分類圖如下：

這是Java IO比較基本的一些處理流。

4.Java IO舉例

4.1 檔案

Demo:

package com.shuidi.iotest;

import java.io.File;

public class FileTest {

    public static void main(String[] args) {
        createFile();  
    }  

    /** 
     * File test
    */  
    public static void createFile() {
        File f = new File("create.txt");
        try{
            f.createNewFile();  
            System.out.println("該分割槽大小"+f.getTotalSpace()/(1024*1024*1024)+"G"); //返回由此抽象路徑名錶示的檔案或目錄的名稱。  
            f.mkdirs();  //建立此抽象路徑名指定的目錄，包括所有必需但不存在的父目錄。  
            //f.delete(); //  刪除此抽象路徑名錶示的檔案或目錄 
            System.out.println("檔名  "+f.getName());  //  返回由此抽象路徑名錶示的檔案或目錄的名稱。
            System.out.println("檔案父目錄字串 "+f.getParent());// 返回此抽象路徑名父目錄的路徑名字串；如果此路徑名沒有指定父目錄，則返回 null。  
          } catch (Exception e) {  
              e.printStackTrace();  
       }
    }
}

輸出：

該分割槽大小131G
檔名  create.txt
檔案父目錄字串 null

4.2 位元組流

4.2.1 輸入流InputStream

package com.shuidi.iotest;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class FileInputStreamTest {

    public static void main(String[] args) {
        int count=0;  //統計檔案位元組長度  
        InputStream streamReader = null;   //檔案輸入流  
        try {
            streamReader = new FileInputStream(new File("FileInoutStreamTest.jpg"));
            System.out.println("---長度是： "+ streamReader.available() +" 位元組");
            byte[] b = new byte[1024];
            int temp;
            while( (temp = streamReader.read(b)) != -1) {  //讀取檔案位元組，並遞增指標到下一個位元組  
                if (temp != 1024 && temp != -1) {
                    System.out.println("---最後讀出的長度是： "+ temp +" 位元組");  
                }
                count++;
            }
            System.out.println("---最後讀出的長度是： "+ temp +" 位元組");  
            System.out.println("---長度是： "+ count +" 位元組");  
          } catch (IOException e) {  
              //TODO 自動生成的 catch 塊  
              e.printStackTrace();  
          } finally {  
              try{  
                 if (streamReader != null) { streamReader.close(); } 
              }catch (IOException e) {  
                 //TODO 自動生成的 catch 塊  
                 e.printStackTrace();  
              }
        }  
    } 
}

輸出：

---長度是： 51281 位元組
---最後讀出的長度是： 81 位元組
---最後讀出的長度是： -1 位元組
---長度是： 51 位元組

4.2.2 輸出流OutputStream

package com.shuidi.iotest;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamTest {

    public static void main(String[] args) {
        // TODO自動生成的方法存根 
        byte[] buffer = new byte[1024];   //一次取出的位元組數大小,緩衝區大小 
        int numberRead = 0;
        FileInputStream input = null;
        FileOutputStream out = null;
        try {
            input = new FileInputStream("FileInoutStreamTest.jpg");
            out = new FileOutputStream("FileOutputStreamTest.jpg"); //如果檔案不存在會自動建立  
            while ((numberRead = input.read(buffer))!=-1) {  //numberRead的目的在於防止最後一次讀取的位元組小於buffer長度
                out.write(buffer, 0, numberRead);       //否則會自動被填充0  
            }
        } catch (IOException e) {
            // TODO自動生成的 catch 塊 
            e.printStackTrace();  
        } finally {
            try {
                input.close();
                out.close();  
            } catch (IOException e) {
                // TODO自動生成的 catch 塊  
                e.printStackTrace();  
            }         
        }  
    }
}

無輸出

4.2.3 輸入輸出流DataInputStream/DataOutputStream

Demo:

package com.shuidi.iotest;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamTest {

      public static void main(String[]args){
         Member[] members = {new Member("Justin",90),
                            new Member("momor",95),
                            new Member("Bush",88)};
         try {  
            DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("DataStreamTest.txt"));  

            for(Member member:members){
                //寫入UTF字串  
               dataOutputStream.writeUTF(member.getName());
               //寫入int資料  
               dataOutputStream.writeInt(member.getAge());
            }  

            //所有資料至目的地 
            dataOutputStream.flush();
            //關閉流  
            dataOutputStream.close();

            DataInputStream dataInputStream = new DataInputStream(new FileInputStream("DataStreamTest.txt"));  

            //讀出資料並還原為物件 
            for(int i = 0;i < members.length;i++){
               //讀出UTF字串 
               String name = dataInputStream.readUTF();
               //讀出int資料 
               int score = dataInputStream.readInt();
               members[i] = new Member(name,score);
            }  

            //關閉流  
            dataInputStream.close();

            //顯示還原後的資料  
            for(Member member : members){
               System.out.printf("%s\t%d%n",member.getName(),member.getAge());
            }
         } catch (IOException e){
             e.printStackTrace();
         }
      }
}

輸出：

Justin  90
momor   95
Bush    88

4.2.4 PushbackInputStream

package com.shuidi.iotest;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;

public class PushBackInputStreamTest {

    public static void main(String[] args) throws IOException {  
        String str = "hello,rollenholt";  
        PushbackInputStream push = null; // 宣告回退流物件  
        ByteArrayInputStream bat = null; // 宣告位元組陣列流物件  
        bat = new ByteArrayInputStream(str.getBytes());  
        push = new PushbackInputStream(bat); // 建立回退流物件，將拆解的位元組陣列流傳入  
        int temp = 0;  
        while ((temp = push.read()) != -1) { // push.read()逐位元組讀取存放在temp中，如果讀取完成返回-1  
           if (temp == ',') { // 判斷讀取的是否是逗號  
              push.unread('u'); //回到temp的位置  
              temp = push.read(); //接著讀取位元組  
              System.out.print("(回退" + (char) temp + ") "); // 輸出回退的字元  
           } else {  
              System.out.print((char) temp); // 否則輸出字元  
           }  
        }  
    }
}

輸出：

hello(回退u) rollenholt

4.2.5 SequenceInputStream

有些情況下，當我們需要從多個輸入流中向程式讀入資料。此時，可以使用合併流，將多個輸入流合併成一個SequenceInputStream流物件。SequenceInputStream會將與之相連線的流集組合成一個輸入流並從第一個輸入流開始讀取，直到到達檔案末尾，接著從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的檔案末尾為止。合併流的作用是將多個源合併合一個源。其可接收列舉類所封閉的多個位元組流物件。

package com.shuidi.iotest;

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class SequenceInputStreamTest {
      /** 
       * @param args 
       *            SequenceInputStream合併流，將與之相連線的流集組合成一個輸入流並從第一個輸入流開始讀取， 
       *            直到到達檔案末尾，接著從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的檔案末尾為止。 
       *            合併流的作用是將多個源合併合一個源。可接收列舉類所封閉的多個位元組流物件。 
       */  
      public static void main(String[] args) {
         doSequence();  
      }  

      private static void doSequence() {  
         // 建立一個合併流的物件  
         SequenceInputStream sis = null;  
         // 建立輸出流。  
         BufferedOutputStream bos = null;  
         try {  
            // 構建流集合。  
            Vector<InputStream> vector = new Vector<InputStream>();  
            vector.addElement(new FileInputStream("SequenceInputStreamTest1.txt"));  
            vector.addElement(new FileInputStream("SequenceInputStreamTest2.txt"));  
            vector.addElement(new FileInputStream("SequenceInputStreamTest3.txt"));  

            Enumeration<InputStream> e = vector.elements();  

            sis = new SequenceInputStream(e);  

            bos = new BufferedOutputStream(new FileOutputStream("SequenceInputStreamTest4.txt"));  

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

輸入：

SequenceInputStreamTest1.txt：1
SequenceInputStreamTest2.txt：2
SequenceInputStreamTest3.txt：3

輸出：

SequenceInputStreamTest4.txt：123

4.2.6 PrintStream

System.out.print()：System.out這個物件就是PrintStream，這個我們不做過多示例

4.3 字元流

4.3.1 FileReader/PrintWriter

package com.shuidi.iotest;

import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;

public class FileReaderTest {
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        // TODO自動生成的方法存根  
        char[] buffer = new char[512];   //一次取出的位元組數大小,緩衝區大小  
        int numberRead = 0;  
        FileReader reader = null;        //讀取字元檔案的流  
        PrintWriter writer = null;    //寫字元到控制檯的流  

        try {  
           reader = new FileReader("FileReaderTest.txt");  
           writer = new PrintWriter(System.out);  //PrintWriter可以輸出字元到檔案，也可以輸出到控制檯  
           while ((numberRead = reader.read(buffer))!=-1) {  
              writer.write(buffer, 0, numberRead);  
           }  
        } catch (IOException e) {  
           // TODO自動生成的 catch 塊  
           e.printStackTrace();  
        }finally{  
           try {  
              reader.close();  
           } catch (IOException e) {  
              // TODO自動生成的 catch 塊  
              e.printStackTrace();  
           }  
           writer.close();       //這個不用拋異常  
        }
    }  
}

輸出：
FileReaderTest.txt：shuidi

shuidi

4.3.2 BufferedReader/BufferedWriter

package com.shuidi.iotest;

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

public class BufferedReaderWriterTest {

      public static void main(String[] args) {  
         // TODO自動生成的方法存根  
         try {  
            concennateFile("BufferedReader.txt");  
         } catch (IOException e) {  
            // TODO自動生成的 catch 塊  
            e.printStackTrace();  
         }  
      }  

    @SuppressWarnings("resource")
    public static void concennateFile(String fileName) throws IOException{
        String str;

        //構建對該檔案您的輸入流
        BufferedWriter writer = new BufferedWriter(new FileWriter("BufferedWriter.txt"));
        BufferedReader reader = new BufferedReader(new FileReader(fileName));
        try {
            while ((str = reader.readLine()) != null) {
                writer.write(str);
                writer.newLine();
            }
            writer.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                writer.close();
            }
        }
    }
}

BufferedReader.txt:
1
2
3
4
5
BufferedWriter.txt:
1
2
3
4
5

4.3.1 StreamTokenizer

這個類非常有用，它可以把輸入流解析為標記（token）, StreamTokenizer 並非派生自InputStream或者OutputStream，而是歸類於io庫中.

package com.shuidi.iotest;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.StreamTokenizer;

public class StreamTokenizerTest {

    /** 
     * 統計字元數 
     * @param fileName 檔名 
     * @return    字元數 
     */  
    public static void main(String[] args) {  
        String fileName = "StreamTokenizerTest.txt";
        statis(fileName);
    }

    public static long statis(String fileName) {  

        FileReader fileReader = null;  
        try {
            fileReader = new FileReader(fileName);  

            //建立分析給定字元流的標記生成器  
            StreamTokenizer st = new StreamTokenizer(new BufferedReader(  
                    fileReader));  

            //ordinaryChar方法指定字元引數在此標記生成器中是“普通”字元。  
            //下面指定單引號、雙引號和註釋符號是普通字元  
            st.ordinaryChar('\'');  
            st.ordinaryChar('\"');  
            st.ordinaryChar('/');  

            String s;  
            int numberSum = 0;  
            int wordSum = 0;  
            int symbolSum = 0;  
            int total = 0;  

            //nextToken方法讀取下一個Token.  
            //TT_EOF指示已讀到流末尾的常量。  
            while (st.nextToken() != StreamTokenizer.TT_EOF) {  

                //在呼叫 nextToken 方法之後，ttype欄位將包含剛讀取的標記的型別  
                switch (st.ttype) {  

                //TT_EOL指示已讀到行末尾的常量。  
                case StreamTokenizer.TT_EOL:  
                    break;  

                //TT_NUMBER指示已讀到一個數字標記的常量  
                case StreamTokenizer.TT_NUMBER:  
                    //如果當前標記是一個數字，nval欄位將包含該數字的值  
                    s = String.valueOf((st.nval));  
                    System.out.println("數字有："+s);  
                    numberSum ++;  
                    break;  

                //TT_WORD指示已讀到一個文字標記的常量  
                case StreamTokenizer.TT_WORD:  
                    //如果當前標記是一個文字標記，sval欄位包含一個給出該文字標記的字元的字串  
                    s = st.sval;  
                    System.out.println("單詞有： "+s);  
                    wordSum ++;  
                    break;  
                default:  
                    //如果以上3中型別都不是，則為英文的標點符號  
                    s = String.valueOf((char) st.ttype);  
                    System.out.println("標點有： "+s);  
                    symbolSum ++;  
                }  
            }  
            System.out.println("數字有 " + numberSum+"個");  
            System.out.println("單詞有 " + wordSum+"個");  
            System.out.println("標點符號有： " + symbolSum+"個");  
            total = symbolSum + numberSum +wordSum;  
            System.out.println("Total = " + total);  
            return total;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return -1;  
        } finally {  
            if (fileReader != null) {  
                try {  
                    fileReader.close();  
                } catch (IOException e1) {  
                }  
            }  
        }  
    }  

}

輸入：

StreamTokenizerTest.txt
'haha'
word
"I love coding" ，。
23223 3523

輸出：

標點有： '
單詞有： haha
標點有： '
單詞有： word
標點有： "
單詞有： I
單詞有： love
單詞有： coding
標點有： "
單詞有： ，。
數字有：23223.0
數字有：3523.0
數字有 2個
單詞有 6個
標點符號有： 4個
Total = 12