java.io 包下需要掌握的流有 16 個，本篇內容包括：java.io包下需要掌握的流、Java IO 案例。

---

---

一、java.io包下需要掌握的流

java.io 包下需要掌握的流有 16 個：

# 文件專屬：

• java.io.FileInputStream
• java.io.FileOutputStream
• java.io.FileReader
• java.io.FileWriter

# 轉換流：（將字節流轉換成字符流）

• java.io.InputStreamReader
• java.io.OutputStreamWriter

# 緩沖流專屬：

• java.io.BufferedReader
• java.io.BufferedWriter
• java.io.BufferedInputStream
• java.io.BufferedOutputStream

# 數據流專屬：

• java.io.DataInputStream
• java.io.DataOutputStream

# 標準輸出流：

• java.io.PrintWriter
• java.io.PrintStream

# 對象專屬流：

• java.io.ObjectInputStream
• java.io.ObjectOutputStream

二、Java IO 案例

1、Demo 1（FileInputStream）

import java.io.FileInputStream;
import java.io.IOException;/*** java.io.FileInputStream* 1) 文件字節輸入流、萬能的、任何類型的文件都可以采用這個流來讀* 2) 字節的方式，完成輸入（讀）的操作（磁盤 ---> 內存）* public int read() throws IOException* 該方法缺點：一次讀取一個字節byte，這樣內存和硬盤交互太頻繁，時間都耗費在交互上面了*/
public class FileInputStreamTest01 {public static void main(String[] args) {FileInputStream fis = null;try {//創建文件字節輸入流對象fis = new FileInputStream("/Users/lizhengi/test/iodemo/temp.txt");//開始讀int readData = 0;while ((readData = fis.read()) != -1) {System.out.print(readData + " ");}} catch (IOException e) {e.printStackTrace();} finally {//在finally語句塊中確保流一定關閉if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件中：abcdefg

輸出的：97 98 99 100 101 102 103

2、Demo 2（FileInputStream）

import java.io.FileInputStream;
import java.io.IOException;/*** public int read(byte[] b) throws IOException* 該方法一次最多讀取 b.length 個字節* 減少內存和硬盤之間的交互，提高程序的執行效率*/
public class FileInputStreamTest02 {public static void main(String[] args) {FileInputStream fis = null;try {//創建文件字節輸入流對象fis = new FileInputStream("/Users/lizhengi/test/iodemo/temp.txt");//開始讀，采用byte數組byte[] bytes = new byte[4];int readCount = 0;while ((readCount = fis.read(bytes)) != -1) {System.out.print(new String(bytes, 0, readCount));}} catch (IOException e) {e.printStackTrace();} finally {if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件中：abcdefg

輸出的：abcdefg

3、Demo 3（FileInputStream）

import java.io.FileInputStream;
import java.io.IOException;/*** public int available() throws IOException* 返回此輸入流中可以讀取（或跳過）的剩余字節數量* <p>* public long skip(long n) throws IOException* 跳過輸入流中的n個字節的數據不讀*/
public class FileInputStreamTest03 {public static void main(String[] args) {FileInputStream fis = null;try {//創建文件字節輸入流對象fis = new FileInputStream("/Users/lizhengi/test/iodemo/temp.txt");//available()方法 獲取該文件中的總字節數量(此時還未讀文件，所以數量為全部字節數)，存入byte數組中//該方式不是讀大文件，因為byte數組不能太大byte[] bytes = new byte[fis.available()];System.out.println("讀之前文件中還可以讀取的字節數量: " + fis.available());int readCount = fis.read(bytes);System.out.println(new String(bytes));System.out.println("讀之后文件中還可以讀取的字節數量: " + fis.available());//skip(long n)方法 跳過幾個字節不讀
//            fis.skip(3);
//            System.out.println(fis.read());} catch (IOException e) {e.printStackTrace();} finally {if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件中：：abcdefg

輸出的：

? 讀之前文件中還可以讀取的字節數量: 8

? abcdefg

? 讀之后文件中還可以讀取的字節數量: 0

4、Demo 4（FileOutputStream）

import java.io.FileOutputStream;
import java.io.IOException;/*** java.io.FileOuputStream* 1) 文件字節輸出流，負責寫* 2) 從內存 ---> 硬盤*/
public class FileOutputStreamTest01 {public static void main(String[] args) {FileOutputStream fos = null;try {//創建文件字節輸出流對象，文件不存在時會自動新建//該方法會先將原文件清空，然后重新寫入，謹慎使用！！！//fos=new FileOutputStream("F:/myfile.txt");//下面這種方法在文件末尾追加寫入，不會清空原文件內容fos = new FileOutputStream("/Users/lizhengi/test/iodemo/demo.txt", true);//開始寫byte[] bytes = {97, 98, 99, 100};fos.write(bytes);//寫完之后，最后一定記得刷新fos.flush();} catch (IOException e) {e.printStackTrace();} finally {if (fos != null) {try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件中：abcd

5、Demo5（FileInputStream & FileOutputStream完成文件的拷貝）

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;/*** 使用 FileInputStream 和 FileOutputStream 完成對文件的復制*/
public class CopyTest01 {public static void main(String[] args) {FileInputStream fis = null;FileOutputStream fos = null;try {//創建一個文件輸入流對象fis = new FileInputStream("/Users/lizhengi/test/iodemo/temp.txt");//創建一個文件輸出流對象fos = new FileOutputStream("/Users/lizhengi/test/iodemo/demo.txt");//核心：一邊讀，一邊寫byte[] bytes = new byte[1024]; //1024B=1KB (一次最多讀1KB)int readCount = 0;while ((readCount = fis.read(bytes)) != -1) {fos.write(bytes, 0, readCount);}} catch (IOException e) {e.printStackTrace();} finally {if (fis == null) {try {assert false;fis.close();} catch (IOException e) {e.printStackTrace();}}if (fos == null) {try {assert false;fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}

輸入文件中：abcd

輸出文件中：abcd

6、Demo 6（FileReader）

import java.io.FileReader;
import java.io.IOException;/*** java.io.FileReader* 文件字符輸入流，只能讀取普通文本* 讀取普通文本時，比較方便快捷* 能用記事本編輯的都是普通文本文件*/
public class FileReaderTest {public static void main(String[] args) {FileReader reader = null;try {//創建文件字符輸入流對象reader = new FileReader("/Users/lizhengi/test/iodemo/temp.txt");//開始讀，字節對應的是byte數組，字符對應的是char數組char[] chars = new char[4]; //一次讀取4個字符int readCount = 0;while ((readCount = reader.read(chars)) != -1) {System.out.print(new String(chars, 0, readCount));}} catch (IOException e) {e.printStackTrace();} finally {if (reader != null) {try {reader.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件中：abcdefg

輸出的：abcdefg

7、Demo 7（FileWriter）

import java.io.FileWriter;
import java.io.IOException;/*** java.io.FileWriter* 文件字符輸出流，負責寫* 只能輸出普通文本* 能用記事本編輯的都是普通文本文件*/
public class FileWriterTest {public static void main(String[] args) {FileWriter writer = null;try {//創建文件字符輸出流對象writer = new FileWriter("/Users/lizhengi/test/iodemo/temp.txt");//開始寫char[] chars = {'我', '是', '中', '國', '人'};writer.write(chars);writer.write(chars, 2, 3);writer.write("Java");//刷新writer.flush();} catch (IOException e) {e.printStackTrace();} finally {if (writer != null) {try {writer.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件中：我是中國人中國人Java

8、Demo 8（FileReader & FileWriter 完成對文件的拷貝）

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;/*** 使用 FileReader 和 FileWriter 完成對文件的復制，只能拷貝普通文本文件* 能用記事本編輯的都是普通文本文件*/
public class CopyTest02 {public static void main(String[] args) {FileReader reader = null;FileWriter writer = null;try {//讀reader = new FileReader("/Users/lizhengi/test/iodemo/temp.txt");//寫writer = new FileWriter("/Users/lizhengi/test/iodemo/demo.txt");//一邊讀一邊寫char[] chars = new char[512]; //一次讀取512字節(0.5KB)int readCount = 0;while ((readCount = reader.read(chars)) != -1) {writer.write(chars, 0, readCount);}} catch (IOException e) {e.printStackTrace();} finally {if (reader != null) {try {reader.close();} catch (IOException e) {e.printStackTrace();}}if (writer != null) {try {writer.close();} catch (IOException e) {e.printStackTrace();}}}}
}

輸入文件中：我是中國人中國人Java

輸出文件中：我是中國人中國人Java

9、Demo 9（BufferedReader）

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;/*** java.io.BufferedReader* 帶有緩沖區的字符輸入流* 使用帶緩沖區的流的時候不需要自定義byte數組、char數組**/
public class BufferedReaderTest01 {public static void main(String[] args) {BufferedReader br = null;try {//當一個流的構造方法中需要另一個流的時候，內部被傳進來的流叫做 節點流//外部負責包裝的流叫做 包裝流//也就是說此時，FileReader是節點流，BufferedReader是包裝流br = new BufferedReader(new FileReader("/Users/lizhengi/test/iodemo/temp.txt"));//循環讀，一次讀一行String s = null;while ((s = br.readLine()) != null) {System.out.println(s);}} catch (IOException e) {e.printStackTrace();} finally {//關閉的時候只需要關閉包裝流即可，而里面的節點流會自動關閉（詳情見源代碼）if (br != null) {try {br.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件中：

? 我是中國人

? 中國人

? Java

輸出的：

? 我是中國人

? 中國人

? Java

10、Demo 10（BufferedReader）

import java.io.*;public class BufferedReaderTest02 {public static void main(String[] args) throws IOException {//最內部是 一個文件字節 輸入流//中間的是 一個字節流轉字符流 的輸入流//最外部是 一個緩沖字符 輸入流 （也就是實現了字節流 ---> 字符流）BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("/Users/lizhengi/test/iodemo/temp.txt")));//開始讀String line = null;while ((line = br.readLine()) != null) {System.out.println(line);}//只需關閉最外部的包裝流即可br.close();}
}

文件中：

? 我是中國人

? 中國人

? Java

輸出的：

? 我是中國人

? 中國人

? Java

11、Demo 11（BufferedWriter）

import java.io.*;public class BufferedWriterTest01 {public static void main(String[] args) throws IOException {//創建一個緩沖字符輸出流//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("/Users/lizhengi/test/iodemo/demo.txt")));BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("/Users/lizhengi/test/iodemo/demo.txt", true)));//開始寫bw.write("Hello World!!!");bw.write("\n");bw.write("Java I/O流");bw.write("\n");//刷新bw.flush();//關閉最外部的包裝流bw.close();}
}

文件中：

? Hello World!!!

? Java I/O流

12、Demo 12（DataOuputStream）

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;/*** java.io.DataOutputStream 數據專屬的字節輸出流* 這個流可以將數據連同數據的類型一并寫入文件（該文件不是普通的文本文件，無法用記事本打開）*/
public class DataOutputStreamTest {public static void main(String[] args) throws IOException {//創建數據專屬的字節輸出流DataOutputStream dos=new DataOutputStream(new FileOutputStream("/Users/lizhengi/test/iodemo/data"));//寫數據byte b=100;short s=200;int i=300;long j=400;float f=0.5F;double d=3.14;boolean flag=false;char a='我';dos.writeByte(b);dos.writeShort(s);dos.writeInt(i);dos.writeLong(j);dos.writeFloat(f);dos.writeDouble(d);dos.writeBoolean(flag);dos.writeChar(a);//刷新dos.flush();//關閉dos.close();}
}

13、Demo 13（DataInputStream）

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;/*** java.io.DataInputStream 數據專屬的字節輸入流* DataOutputStream 寫的文件只能使用 DataInputStream 來讀，同時讀的順序必須和寫的順序一樣*/
public class DataInputStreamTest {public static void main(String[] args) throws IOException {//創建數據專屬的字節輸入流DataInputStream dis=new DataInputStream(new FileInputStream("/Users/lizhengi/test/iodemo/data"));//開始讀byte b=dis.readByte();short s=dis.readShort();int i=dis.readInt();long j=dis.readLong();float f=dis.readFloat();double d=dis.readDouble();boolean flag=dis.readBoolean();char a=dis.readChar();System.out.println(b);System.out.println(s);System.out.println(i);System.out.println(j);System.out.println(f);System.out.println(d);System.out.println(flag);System.out.println(a);//關閉dis.close();}
}

輸出的：

? 100

? 200

? 300

? 400

? 0.5

? 3.14

? false

? 我

14、Demo 14（PrintStream）

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;/*** java.io.PrintStream* 標準字節輸出流，默認直接輸出到控制臺*/
public class PrintStreamTest {public static void main(String[] args) throws FileNotFoundException {System.out.println("Hello World!!!");//創建一個標準字節輸出流對象PrintStream ps = System.out;ps.println("Java I/O流");ps.println("Java 666");ps.println(123);//標準輸出流不需要手動調用close方法關閉//修改標準字節輸出流的輸出方向，輸出到 log 文件PrintStream printStrea m= new PrintStream(new FileOutputStream("/Users/lizhengi/test/iodemo/log"));System.setOut(printStream);//再次輸出，將不會輸出到控制臺System.out.println("Java I/O流");System.out.println("Java 666");System.out.println(999);}
}

輸出的：

? Hello World!!!
? Java I/O流
? Java 666
? 123

文件中：
Java I/O流
Java 666
999

15、Demo 15（I/O流聯合Properties屬性類使用）

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;/*** I/O流和Properties的聯合使用* 設計理念：以后經常改變的數據，可以單獨寫道一個文件中，使用程序動態讀取* 將來只需要修改這個文件的內容，Java代碼不需要修改，不需要重新編譯，服務器也不需要重啟，就可以拿到動態的數據* <p>* 類似于以上機制的文件被稱為配置文件，其中的格式為* key1=value1* key2=value2 (key重復的情況下，value會自動覆蓋)* 的時候，我們把這種配置文件稱為屬性配置文件，例如：jdbc.properties* Java中有規范要求，屬性配置文件需要以 .properties 結尾，但這不是必須的* Properties類是Java中專門存放屬性配置文件的一個類*/
public class IoPropertiesTest {public static void main(String[] args) throws IOException {//Properties是一個Map集合，繼承了Hashtable，其key和value都是String類型//這里打算將一個文件中的數據加載到Properties對象中//新建一個文件字符輸入流對象FileReader reader = new FileReader("/Users/lizhengi/test/iodemo/userinfo.txt");//創建一個Properties集合Properties properties = new Properties();//調用Properties對象的load方法，將文件中的數據加載到Properties集合中properties.load(reader);//通過文件中的key獲取對應的valueString username = properties.getProperty("username");String password = properties.getProperty("password");System.out.println(username);System.out.println(password);}
}

文件中：

? username=root

? password=12345678

? key=value

輸出的：

? root

? 12345678

16、Demo 16（File）

import java.io.File;public class FileTest01 {public static void main(String[] args) {File file = new File("/Users/lizhengi/test/iodemo/");//獲取當前目錄下的所有子文件File[] files = file.listFiles();for (File file1 : files) {//獲取所有子文件的絕對路徑//System.out.println(file1.getAbsolutePath());//獲取所有子文件的文件名System.out.println(file1.getName());}}
}

輸出的：

? demo.txt
? .userinfo.txt.swp
? temp.txt
? log
? userinfo.txt
? data