Java IO操作——位元組流(OutputStream、InputStream)和字元流(Writer、Reader)
阿新 • • 發佈：2019-02-15
學習目標
掌握流的概念 掌握位元組流與字元流的作用 掌握檔案的標準操作步驟 掌握位元組與字元操作的區別流的概念
在程式中所有的資料都是以流的方式進行傳輸或儲存的，程式中需要資料的時候就用輸入流讀取資料，而當程式需要將一些資料儲存起來的時候，就要使用輸出流完成。
程式中的輸入輸出都是以流的形式儲存的，流中儲存的實際上全部是位元組檔案。
位元組流與字元流
在java.io包中操作檔案內容的主要有兩大類：位元組流和字元流，兩類都分為輸入和輸出操作。在位元組流中輸出資料主要是使用OutputStream完成，輸入使用InputStream，在字元流中輸出主要是使用Writer類完成，輸入主要是使用Reader類完成。位元組流
位元組流主要是操作byte型別的資料，以byte陣列為準，主要操作類是OutputStream、InputStream位元組輸出流OutputStream
OutputStream是整個io包中位元組輸出流的最大父類，此類的定義如下： public abstract class OutputStream extends Object implements Closeable, Flushable 從以上的定義可以發現，此類是一個抽象類，如果要想使用此類的話，則首先必須通過子類例項化物件，那麼如果現在要操作的是一個檔案，則可以使用：FileOutputStream類。通過向上轉型之後，可以為OutputStream例項化。import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo01{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
OutputStream out = null ; // 準備好一個輸出的物件
out = new FileOutputStream(f) ; // 通過物件多型性，進行例項化
// 第3步、進行寫操作
String str = "Hello World!!!" ; // 準備一個字串
byte b[] = str.getBytes() ; // 只能輸出byte陣列，所以將字串變為byte陣列
out.write(b) ; // 將內容輸出，儲存檔案
// 第4步、關閉輸出流
out.close() ; // 關閉輸出流
}
};
在操作的時候，如果檔案本身不存在，則會為使用者自動建立新檔案。 在操作輸出流的時候，也可以使用write(int i)的方法寫出資料
import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo02{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
OutputStream out = null ; // 準備好一個輸出的物件
out = new FileOutputStream(f) ; // 通過物件多型性，進行例項化
// 第3步、進行寫操作
String str = "Hello World!!!" ; // 準備一個字串
byte b[] = str.getBytes() ; // 只能輸出byte陣列，所以將字串變為byte陣列
for(int i=0;i<b.length;i++){ // 採用迴圈方式寫入
out.write(b[i]) ; // 每次只寫入一個內容
}
// 第4步、關閉輸出流
out.close() ; // 關閉輸出流
}
};import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo03{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
OutputStream out = null ; // 準備好一個輸出的物件
out = new FileOutputStream(f,true) ; // 此處表示在檔案末尾追加內容
// 第3步、進行寫操作
String str = "Hello World!!!" ; // 準備一個字串
byte b[] = str.getBytes() ; // 只能輸出byte陣列，所以將字串變為byte陣列
for(int i=0;i<b.length;i++){ // 採用迴圈方式寫入
out.write(b[i]) ; // 每次只寫入一個內容
}
// 第4步、關閉輸出流
out.close() ; // 關閉輸出流
}
};
程式本身是可以追加內容的，但是沒有換行，是直接在末尾追加的。 如果在檔案操作中想換行的話，使用"\r\n" 完成。 程式碼如下：
import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo04{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
OutputStream out = null ; // 準備好一個輸出的物件
out = new FileOutputStream(f,true) ; // 此處表示在檔案末尾追加內容
// 第3步、進行寫操作
String str = "\r\nHello World!!!" ; // 準備一個字串
byte b[] = str.getBytes() ; // 只能輸出byte陣列，所以將字串變為byte陣列
for(int i=0;i<b.length;i++){ // 採用迴圈方式寫入
out.write(b[i]) ; // 每次只寫入一個內容
}
// 第4步、關閉輸出流
out.close() ; // 關閉輸出流
}
};
位元組輸入流：InputStream
既然程式可以向檔案中寫入內容，則就可以通過InputStream從檔案中讀取出來，首先看InputStream類的定義： public abstract class InputStream extends Object implements Closeable 與OutputStream類一樣，InputStream本身也是一個抽象類，必須依靠其子類，如果現在是從檔案中讀取，子類肯定是FileInputStream。觀察FileInputStream類的構造方法： public FileInputStream(File file) throws FileNotFoundException InputStream類的常用方法如下： 1、public int available() throws IOException 可以取得輸入檔案的大小。 2、public void close() throws IOException 關閉輸入流 3、public abstract int read() throws IOException 讀取內容數字的方式讀取 4、public int read(byte[] b) throws IOException 將內容讀取到byte陣列之中，同時返回讀入的個數 程式程式碼如下：import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo01{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
InputStream input = null ; // 準備好一個輸入的物件
input = new FileInputStream(f) ; // 通過物件多型性，進行例項化
// 第3步、進行讀操作
byte b[] = new byte[1024] ; // 所有的內容都讀到此陣列之中
input.read(b) ; // 讀取內容
// 第4步、關閉輸出流
input.close() ; // 關閉輸出流
System.out.println("內容為：" + new String(b)) ; // 把byte陣列變為字串輸出
}
};
此時，內容確實已經被讀取出來了，但是存在問題。 初步修改程式碼後如下：
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo02{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
InputStream input = null ; // 準備好一個輸入的物件
input = new FileInputStream(f) ; // 通過物件多型性，進行例項化
// 第3步、進行讀操作
byte b[] = new byte[1024] ; // 所有的內容都讀到此陣列之中
int len = input.read(b) ; // 讀取內容
// 第4步、關閉輸出流
input.close() ; // 關閉輸出流\
System.out.println("讀入資料的長度：" + len) ;
System.out.println("內容為：" + new String(b,0,len)) ; // 把byte陣列變為字串輸出
}
};
以上程式碼還是存在問題，現在檔案沒有那麼大，但是開闢了很大的陣列空間，肯定浪費很多記憶體，應該根據檔案的大小來開闢陣列空間。如果想知道檔案的大小，直接使用File類即可： public long length() 開闢指定大小的空間
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo03{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
InputStream input = null ; // 準備好一個輸入的物件
input = new FileInputStream(f) ; // 通過物件多型性，進行例項化
// 第3步、進行讀操作
byte b[] = new byte[(int)f.length()] ; // 陣列大小由檔案決定
int len = input.read(b) ; // 讀取內容
// 第4步、關閉輸出流
input.close() ; // 關閉輸出流\
System.out.println("讀入資料的長度：" + len) ;
System.out.println("內容為：" + new String(b)) ; // 把byte陣列變為字串輸出
}
};
以上是直接使用byte陣列的方式完成的，還可以使用以下方式進行讀取 public abstract int read() throws IOException逐個位元組進行內容讀取 程式碼如下：
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo04{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
InputStream input = null ; // 準備好一個輸入的物件
input = new FileInputStream(f) ; // 通過物件多型性，進行例項化
// 第3步、進行讀操作
byte b[] = new byte[(int)f.length()] ; // 陣列大小由檔案決定
for(int i=0;i<b.length;i++){
b[i] = (byte)input.read() ; // 讀取內容
}
// 第4步、關閉輸出流
input.close() ; // 關閉輸出流\
System.out.println("內容為：" + new String(b)) ; // 把byte陣列變為字串輸出
}
};
以上的操作，只適合於知道輸入流大小的時候，如果現在不知道大小呢？ 需要根據讀取的標誌-1進行判斷是否結束，程式碼如下：
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo05{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
InputStream input = null ; // 準備好一個輸入的物件
input = new FileInputStream(f) ; // 通過物件多型性，進行例項化
// 第3步、進行讀操作
byte b[] = new byte[1024] ; // 陣列大小由檔案決定
int len = 0 ;
int temp = 0 ; // 接收每一個讀取進來的資料
while((temp=input.read())!=-1){
// 表示還有內容，檔案沒有讀完
b[len] = (byte)temp ;
len++ ;
}
// 第4步、關閉輸出流
input.close() ; // 關閉輸出流\
System.out.println("內容為：" + new String(b,0,len)) ; // 把byte陣列變為字串輸出
}
};字元流
在程式中一個字元等於2個位元組，那麼JAVA提供了Reader、Writer兩個專門操作字元流的類。字元輸出流：Writer
Writer本身是一個字元流的輸出類，此類的定義如下： public abstract class Writer extends Object implements Appendable，Closeable,，Flushable 此類也是一個抽象類，如果要想使用此類，則肯定要使用其子類。此時如果是向檔案中寫入內容，所以應該使用FileWriter的子類。 FileWriter類的構造方法定義如下： public FileWriter(File file) throws IOException Writer類的常用方法 1、public abstract void close() throws IOException 關閉輸出流 2、public void write(String str) throws IOException 將字串輸出 3、public void write(char[] cbuf) throws IOException 將字元陣列輸出 4、public abstract void flush() throws IOException 強制性清空快取 字元流的操作比位元組流操作好在一點，就是可以直接輸出字串。不在用再像之前那樣進行位元組轉換操作了。import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo01{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
Writer out = null ; // 準備好一個輸出的物件
out = new FileWriter(f) ; // 通過物件多型性，進行例項化
// 第3步、進行寫操作
String str = "Hello World!!!" ; // 準備一個字串
out.write(str) ; // 將內容輸出，儲存檔案
// 第4步、關閉輸出流
out.close() ; // 關閉輸出流
}
};import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo02{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
Writer out = null ; // 準備好一個輸出的物件
out = new FileWriter(f,true) ; // 通過物件多型性，進行例項化
// 第3步、進行寫操作
String str = "\r\n劉勳\r\nHello World!!!" ; // 準備一個字串
out.write(str) ; // 將內容輸出，儲存檔案
// 第4步、關閉輸出流
out.close() ; // 關閉輸出流
}
};
字元輸入流：Reader
Reader是使用字元的方式從檔案之中取出資料，Reader類的定義如下： public abstract class Reader extends Object implements Readable，Closeable Reader本身也是抽象類，如果現在要從檔案中讀取內容，則可以直接使用FileReader子類。 FileReader的構造方法定義如下： public FileReader(File file) throws FileNotFOundException Reader類的常用方法： 1、public abstract void close() throws IOException 關閉輸出流 2、public int read() throws IOException 讀取單個字元 3、public int read(char[] cbuf) throws IOException 將字元讀取到字元陣列之中，返回讀入的長度。 以字元陣列的形式讀取資料import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo01{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
Reader input = null ; // 準備好一個輸入的物件
input = new FileReader(f) ; // 通過物件多型性，進行例項化
// 第3步、進行讀操作
char c[] = new char[1024] ; // 所有的內容都讀到此陣列之中
int len = input.read(c) ; // 讀取內容
// 第4步、關閉輸出流
input.close() ; // 關閉輸出流
System.out.println("內容為：" + new String(c,0,len)) ; // 把字元陣列變為字串輸出
}
};import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo02{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
Reader input = null ; // 準備好一個輸入的物件
input = new FileReader(f) ; // 通過物件多型性，進行例項化
// 第3步、進行讀操作
char c[] = new char[1024] ; // 所有的內容都讀到此陣列之中
int temp = 0 ; // 接收每一個內容
int len = 0 ; // 讀取內容
while((temp=input.read())!=-1){
// 如果不是-1就表示還有內容，可以繼續讀取
c[len] = (char)temp ;
len++ ;
}
// 第4步、關閉輸出流
input.close() ; // 關閉輸出流
System.out.println("內容為：" + new String(c,0,len)) ; // 把字元陣列變為字串輸出
}
};位元組流與字元流的區別
位元組流在操作的時候本身是不會用到緩衝區(記憶體)的，是與檔案本身直接操作的，而字元流在操作的時候是使用到緩衝區的。
通過一個程式碼來驗證字元流使用到了快取。
import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo05{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
OutputStream out = null ; // 準備好一個輸出的物件
out = new FileOutputStream(f) ; // 例項化
// 第3步、進行寫操作
String str = "Hello World!!!" ; // 準備一個字串
byte b[] = str.getBytes() ; // 只能輸出byte陣列，所以將字串變為byte陣列
out.write(b) ; // 寫入資料
// 第4步、關閉輸出流
// out.close() ; // 關閉輸出流
}
};
在使用位元組流操作中，即使沒有關閉，最終也是可以輸出的 使用字元流，如果不關閉，如下：
import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo03{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
Writer out = null ; // 準備好一個輸出的物件
out = new FileWriter(f) ; // 通過物件多型性，進行例項化
// 第3步、進行寫操作
String str = "Hello World!!!" ; // 準備一個字串
out.write(str) ; // 將內容輸出，儲存檔案
// 第4步、關閉輸出流
// out.close() ; // 此時，沒有關閉
}
};
以上的操作，沒有輸出任何的內容，以前的內容也會被清空，也就是說，所有的內容現在都是儲存在緩衝區中，如果執行關閉操作的時候會強制重新整理緩衝區，所以可以把內容輸出。 如果現在假設，沒有關閉的話，也可以手工強制性呼叫重新整理方法 public abstract void flush() throws IOException 程式程式碼如下：
import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo04{
public static void main(String args[]) throws Exception{ // 異常丟擲，不處理
// 第1步、使用File類找到一個檔案
File f= new File("d:" + File.separator + "test.txt") ; // 宣告File物件
// 第2步、通過子類例項化父類物件
Writer out = null ; // 準備好一個輸出的物件
out = new FileWriter(f) ; // 通過物件多型性，進行例項化
// 第3步、進行寫操作
String str = "Hello World!!!" ; // 準備一個字串
out.write(str) ; // 將內容輸出，儲存檔案
// 第4步、關閉輸出流
out.flush() ; // 強制性清空緩衝區中的內容
// out.close() ; // 此時，沒有關閉
}
};
問題： 開發中是使用位元組流好還是使用字元流好 在所有的硬碟上儲存檔案或是進行傳輸的時候都是以位元組的方式進行的，包括圖片也是按照位元組完成，而字元是隻有在記憶體中才會形成的，所以使用位元組操作是最多的。
操作範例
檔案拷貝：在DOS命令中存在一個檔案的拷貝命令(copy)，例如：現在要將D盤中的test.txt檔案拷貝到D盤中的demo.txt檔案中，則只要在命令列輸入copy即可完成 copy命令的語法格式如下： copy 原始檔 目標檔案 如果要採用以上的格式，則肯定要使用初始化引數的形式，輸入兩個路徑，所以此時就必須對輸入引數的個數進行驗證，判斷其是否為2 是使用字元流還是使用位元組流呢？答案是肯定選擇位元組流，因為萬一拷貝的是一個圖片。 實現一：將原始檔中的內容全部讀取進來，之後一次性的寫入到目標檔案 實現二：邊度邊寫的方式 很明顯是使用第二種方式 程式程式碼如下：import java.io.* ;
public class Copy{
public static void main(String args[]){
if(args.length!=2){ // 判斷是否是兩個引數
System.out.println("輸入的引數不正確。") ;
System.out.println("例：java Copy 原始檔路徑 目標檔案路徑") ;
System.exit(1) ; // 系統退出
}
File f1 = new File(args[0]) ; // 原始檔的File物件
File f2 = new File(args[1]) ; // 目標檔案的File物件
if(!f1.exists()){
System.out.println("原始檔不存在！") ;
System.exit(1) ;
}
InputStream input = null ; // 準備好輸入流物件，讀取原始檔
OutputStream out = null ; // 準備好輸出流物件，寫入目標檔案
try{
input = new FileInputStream(f1) ;
}catch(FileNotFoundException e){
e.printStackTrace() ;
}
try{
out = new FileOutputStream(f2) ;
}catch(FileNotFoundException e){
e.printStackTrace() ;
}
if(input!=null && out!=null){ // 判斷輸入或輸出是否準備好
int temp = 0 ;
try{
while((temp=input.read())!=-1){ // 開始拷貝
out.write(temp) ; // 邊讀邊寫
}
System.out.println("拷貝完成！") ;
}catch(IOException e){
e.printStackTrace() ;
System.out.println("拷貝失敗！") ;
}
try{
input.close() ; // 關閉
out.close() ; // 關閉
}catch(IOException e){
e.printStackTrace() ;
}
}
}
}