今天小編給大家分享一下JAVA的IO流、File、字節(jié)流及字符流實例分析的相關知識點，內(nèi)容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。
創(chuàng)新互聯(lián)建站是一家集網(wǎng)站建設,余杭企業(yè)網(wǎng)站建設,余杭品牌網(wǎng)站建設,網(wǎng)站定制,余杭網(wǎng)站建設報價,網(wǎng)絡營銷,網(wǎng)絡優(yōu)化,余杭網(wǎng)站推廣為一體的創(chuàng)新建站企業(yè)，幫助傳統(tǒng)企業(yè)提升企業(yè)形象加強企業(yè)競爭力。可充分滿足這一群體相比中小企業(yè)更為豐富、高端、多元的互聯(lián)網(wǎng)需求。同時我們時刻保持專業(yè)、時尚、前沿，時刻以成就客戶成長自我，堅持不斷學習、思考、沉淀、凈化自己，讓我們?yōu)楦嗟钠髽I(yè)打造出實用型網(wǎng)站。
在學習IO流之前,我們首先需要學習的概念就是Stream流
為了方便理解,我們可以把數(shù)據(jù)的讀寫操作抽象成數(shù)據(jù)在"管道"中流動,但需注意:
1.流只能單方向流動
2.輸入流用來讀取 → in
3.輸出流用來寫出 → out
4.數(shù)據(jù)只能從頭到尾順序的讀寫一次
所以以程序的角度來思考,In/out 相對于程序而言的輸入(讀取)/輸出(寫出)的過程.
在java中,根據(jù)處理的數(shù)據(jù)單位不同,可以把流分為字節(jié)流和字符流
字節(jié)流 : 針對二進制文件
字符流 : 針對文本文件
再結(jié)合對應類型的輸入和輸出方向,常用的流有:
File
字節(jié)流:針對二進制文件
InputStreamFileInputStream
BufferedInputStream
ObjectInputStream
OutputStreamFileOutputStream
BufferedOutputStream
ObjectOutputStream
字符流:針對文本文件
ReaderFileReader
BufferedReader
InputStreamReader
WriterFileWriter
BufferedWriter
OutputStreamWriter
PrintWriter一行行寫出
封裝一個磁盤路徑字符串,對這個路徑可以執(zhí)行一次操作
可以封裝文件路徑、文件夾路徑、不存在的路徑
File(String pathname)通過將給定路徑名字符串轉(zhuǎn)換為抽象路徑名來創(chuàng)建一個新的File實例
new File(“d:/abc/a.txt”);
new File(“d:/abc”,”a.txt”);
創(chuàng)建包: cn.tedu.file
創(chuàng)建類: TestFile.java
重慶分公司
重慶分公司
package cn.tedu.file;import java.io.File;import java.io.IOException;import java.util.Arrays;/*本類用于測試文件類File*/public class TestFile {
public static void main(String[] args) throws IOException {
//1.創(chuàng)建File類對象
/*1.ready目錄與1.txt需要自己手動創(chuàng)建
* 2.File需要導包：import java.io.File;
* 3.路徑是String類型，必須寫正確，不然找不到文件
* 4.完整的文件名包含兩部分：文件名+后綴名*/
File file = new File("E:\\ready\\1.txt");
//2.1測試File中的常用方法
System.out.println(file.length());//3，獲取文件的字節(jié)量
System.out.println(file.exists());//true,判斷文件是否存在
System.out.println(file.isFile());//true,判斷是否為文件
System.out.println(file.isDirectory());//false，判斷是否為文件夾
System.out.println(file.getName());//1.txt獲取文件名
System.out.println(file.getParent());//E:\ready 獲取父級路徑
System.out.println(file.getAbsolutePath());//E:\ready\1.txt 獲取帶盤符的完整路徑：絕對路徑
//2.2 測試創(chuàng)建與刪除
/*new 只會幫你在內(nèi)存中創(chuàng)建一個File類型的對象
* 并不會幫你在磁盤中創(chuàng)建一個真實存在的2.txt文件*/
file = new File("E:\\ready\\2.txt");
//創(chuàng)建一個之前不存在的文件2.txt,如果創(chuàng)建成功，會返回true
/*如果指定創(chuàng)建文件的路徑不對，會拋出異常：java.io.Exception
* 所以需要提前處理這個問題，我們暫時選擇在main()上拋出
* 這個IO異常是目前我們遇到的強制要求必須預先處理的異常
* 如果不處理，方法的調(diào)用會報錯，通不過編譯*/
System.out.println(file.createNewFile());//創(chuàng)建之前不存在的文件
file = new File("E:\\ready\\m");
System.out.println(file.mkdir());//創(chuàng)建之前不存在的單層文件夾
file = new File("E:\\ready\\a\\b\\c");
System.out.println(file.mkdirs());//創(chuàng)建之前不存在的多層文件夾
System.out.println(file.delete());//c被刪除，刪除空文件夾或者文件
file = new File("E:\\ready\\a");
System.out.println(file.delete());//false,a文件夾不是空的，里面有內(nèi)容
file = new File("E:\\ready\\2.txt");
System.out.println(file.delete());//2.txt被刪除，可以刪除文件
//2.3測試展示文件列表
file = new File("E:\\ready");
String[] list = file.list();/*不常用*/
System.out.println(Arrays.toString(list));
//這句話會報錯，因為這是一個String[],所以數(shù)組中每個元素都是String類型的
//那么只能用String類中的方法，而isDirectory()是File類中的方法
//System.out.println(list[0].isDirectory());
File[] fs = file.listFiles();/*常用*/
System.out.println(Arrays.toString(fs));
System.out.println(fs[0].isDirectory());
}}字節(jié)流是由字節(jié)組成的,字符流是由字符組成的.
Java里字符由兩個字節(jié)組成.字節(jié)流是基本流，主要用在處理二進制數(shù)據(jù)。
所以字節(jié)流是比較常用的，可以可以處理多種不同種類的文件，比如文本文檔/音頻/視頻等等
此抽象類是表示字節(jié)輸入流的所有類的超類/抽象類,不可創(chuàng)建對象哦
常用方法：
abstract int read() 從輸入流中讀取數(shù)據(jù)的下一個字節(jié)
int read(byte[] b) 從輸入流中讀取一定數(shù)量的字節(jié)，并將其存儲在緩沖區(qū)數(shù)組 b 中
int read(byte[] b, int off, int len) 將輸入流中最多 len 個數(shù)據(jù)字節(jié)讀入 byte 數(shù)組,off表示存時的偏移量
void close() 關閉此輸入流并釋放與該流關聯(lián)的所有系統(tǒng)資源
直接插在文件上，直接讀取文件數(shù)據(jù)
創(chuàng)建對象
FileInputStream(File file)—直接傳文件對象
通過打開一個到實際文件的連接來創(chuàng)建一個 FileInputStream，該文件通過文件系統(tǒng)中的 File 對象 file 指定FileInputStream(String pathname)—傳路徑
通過打開一個到實際文件的連接來創(chuàng)建一個 FileInputStream，該文件通過文件系統(tǒng)中的路徑名 name 指定
BufferedInputStream 為另一個輸入流添加一些功能，在創(chuàng)建BufferedInputStream 時，會創(chuàng)建一個內(nèi)部緩沖區(qū)數(shù)組(默認8k大小)。在讀取或跳過流中的字節(jié)時，可根據(jù)需要從包含的輸入流再次填充該內(nèi)部緩沖區(qū)，一次填充多個字節(jié)。
創(chuàng)建對象
BufferedInputStream(InputStream in)
創(chuàng)建一個 BufferedInputStream 并保存其參數(shù)，即輸入流 in，以便將來使用。
創(chuàng)建包: cn.tedu.file
創(chuàng)建類: TestIn.java
package cn.tedu.file;import java.io.*;/*本類用于練習字節(jié)輸入流*/public class TestIn {
public static void main(String[] args) {
//method();//字節(jié)流的讀取
method2();//高效字節(jié)流的讀取
}
//本方法用于測試高效字節(jié)流的讀取
private static void method2() {
//定義一個在本方法中都生效的局部變量in,注意手動初始化，值為null
InputStream in = null;
try {
//1.創(chuàng)建高效字節(jié)輸入流對象// InputStream in = new BufferedInputStream(// new FileInputStream(new File("E:\\ready\\1.txt")));
in = new BufferedInputStream
(new FileInputStream("E:\\ready\\1.txt"));
//2.使用流進行讀取
int b;
while ((b= in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
}finally {//關流操作寫在finally{}中
//3.流用完以后一定要關閉?。?！
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于測試字節(jié)流的讀取
private static void method() {
//創(chuàng)建一個在本方法都生效的局部變量注意手動初始化
InputStream in = null;
try {
//1.創(chuàng)建字節(jié)輸入流對象用于讀取
//InputStream in = new InputStream();//報錯原因：抽象類不可實例化
//InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
in = new FileInputStream("E:\\ready\\1.txt");
//2.開始讀取
/*read()每次調(diào)用都會讀取一個字節(jié)，如果讀到了數(shù)據(jù)的末尾，返回-1*/// System.out.println(in.read());// System.out.println(in.read());// System.out.println(in.read());// System.out.println(in.read());
//需求：需要循環(huán)讀取文件中的所有內(nèi)容，直至讀完
//定義變量，記錄讀到的數(shù)據(jù)
int b;
while((b=in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();//打印錯誤信息
/*try-catch結(jié)構(gòu)中的第三個部分：finally{}
* 這部分不論是否捕獲到異常，是一定會被執(zhí)行到的代碼，常用于關流*/
}finally {
try {
//3.釋放資源，流資源用完必須釋放?。?！
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}}常用于處理純文本數(shù)據(jù),讀寫容易出現(xiàn)亂碼的現(xiàn)象,在讀寫時,最好指定編碼集為UTF-8
用于讀取字符流的抽象類。
常用方法：
int read() 讀取單個字符
int read(char[] cbuf) 將字符讀入數(shù)組
abstract int read(char[] cbuf, int off, int len) 將字符讀入數(shù)組的某一部分
int read(CharBuffer target) 試圖將字符讀入指定的字符緩沖區(qū)
abstract void close() 關閉該流并釋放與之關聯(lián)的所有資源
用來讀取字符文件的便捷類。此類的構(gòu)造方法假定默認字符編碼和默認字節(jié)緩沖區(qū)大小都是適當?shù)摹Ｒ约褐付ㄟ@些值，可以先在 FileInputStream 上構(gòu)造一個 InputStreamReader。
創(chuàng)建對象
FileReader(String fileName) 在給定從中讀取數(shù)據(jù)的文件名的情況下創(chuàng)建一個新 FileReader
FileReader(File file) 在給定從中讀取數(shù)據(jù)的 File 的情況下創(chuàng)建一個新 FileReader
從字符輸入流中讀取文本，緩沖各個字符，從而實現(xiàn)字符、數(shù)組和行的高效讀取。
可以指定緩沖區(qū)的大小，或者可使用默認的大小。大多數(shù)情況下，默認值就足夠大了。
創(chuàng)建對象
BufferedReader(Reader in) 創(chuàng)建一個使用默認大小輸入緩沖區(qū)的緩沖字符輸入流
創(chuàng)建包: cn.tedu.file
創(chuàng)建類: TestIn2.java
package cn.tedu.file;import java.io.*;/*本類用于測試字符流的讀取*/public class TestIn2 {
public static void main(String[] args) {
//method();//測試普通字符輸入流
method2();//測試高效字符輸入流
}
//創(chuàng)建一個用于測試高效字符輸入流的方法
private static void method2() {
//1.定義一個在本方法都生效的局部變量，手動初始化值null
Reader in=null;
try{
//1.創(chuàng)建高效字符讀取流對象
//in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
//2.使用流對象
int b;
while((b=in.read())!=-1){
System.out.println(b);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//3.關閉流對象
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//創(chuàng)建一個用于測試普通字符輸入流的方法
private static void method() {
//1.1創(chuàng)建一個在本方法中都生效的局部變量，注意初始化值null
Reader in = null;
try {
//1.2創(chuàng)建字符輸入流對象，注意需要捕獲異常
//Reader in = new Reader();//報錯原因：抽象父級不可實例化
//in = new FileReader(new File("E:\\ready\\1.txt"));
in = new FileReader("E:\\ready\\1.txt");
//2.使用流對象
//System.out.println(in.read());
//需求：循環(huán)讀取文件中的所有內(nèi)容，只要不是-1，就說明還有數(shù)據(jù)，繼續(xù)讀取
//3.1定義變量，記錄讀取到的數(shù)據(jù)
int b;
while((b = in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
} finally {//3.關流
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}}此抽象類是表示輸出字節(jié)流的所有類的超類.輸出流接受輸出字節(jié)并將這些字節(jié)發(fā)送到某個接收器.
常用方法:
Void close() 關閉此輸出流并釋放與此流相關的所有系統(tǒng)資源
Void flush() 刷新此輸出流并強制寫出所有緩沖的輸出字節(jié)
Void write(byte[ ] b) 將b.length個字節(jié)從指定的byte數(shù)組寫入此輸出流
Void write(byte[ ] b,int off ,int len) 將指定byte數(shù)組中從偏移量off開始的len個字節(jié)寫入輸出流
Abstract void write(int b) 將指定的字節(jié)寫入此輸出流
直接插在文件上,直接寫出文件數(shù)據(jù)
構(gòu)造方法(創(chuàng)建對象):
FileOutputStream(String name)
創(chuàng)建一個向具有指定名稱的文件中寫入數(shù)據(jù)的文件輸出流
FileOutStream(File file)
創(chuàng)建一個向指定File對象表示的文件中寫入數(shù)據(jù)的文件輸出流
FileOutStream(File file,boolean append)—如果第二個參數(shù)為true,表示追加,不覆蓋
創(chuàng)建一個向指定File對象表示的文件中寫入數(shù)據(jù)的文件輸出流,后面的參數(shù)是指是否覆蓋原文件內(nèi)容
該類實現(xiàn)緩沖的輸出流,通過設置這種輸出流,應用程序就可以將各個字節(jié)寫入底層輸出流中,而不必每次針對字節(jié)寫出調(diào)用底層系統(tǒng)
構(gòu)造方法(創(chuàng)建對象):
BufferedOutputStream(OutputStream out)
創(chuàng)建一個新的緩沖輸出流,用以將數(shù)據(jù)寫入指定的底層輸出流
創(chuàng)建包: cn.tedu.file
創(chuàng)建類: TestOut.java
package cn.tedu.file;import java.io.*;/*本類用于測試字節(jié)輸出流*/public class TestOut {
public static void main(String[] args) {
method();//用于測試普通字節(jié)輸出流
//method2();//用于測試高效字節(jié)輸出流
}
//創(chuàng)建一個用于測試高效字節(jié)輸出流的方法
private static void method2() {
//1.創(chuàng)建一個在本方法都生效的局部變量，注意手動初始化
OutputStream out = null;
try{
//2.創(chuàng)建高效字節(jié)輸出流對象// out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
//3.使用流對象--進行寫出操作
out.write(97);
out.write(97);
out.write(97);
}catch (Exception e){
e.printStackTrace();
}finally {//關流操作要放在finally{}中
try {
//4.關流
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//創(chuàng)建一個用于測試普通字節(jié)輸出流的方法
private static void method() {
//1.創(chuàng)建一個在本方法中都生效的局部變量，注意手動初始化null
OutputStream out = null;
//2.創(chuàng)建try-catch-finally結(jié)構(gòu)，因為IO操作可能會產(chǎn)生異常
try{
//3.創(chuàng)建普通字節(jié)輸出流對象
//out = new FileOutputStream(new File("E:\\ready\\2.txt"));
//out = new FileOutputStream("E:\\ready\\2.txt");
out = new FileOutputStream("E:\\ready\\2.txt",true);
//4.使用流對象--進行寫出操作
out.write(99);//對應ASCII碼表中的a
out.write(99);//對應ASCII碼表中的b
out.write(99);//對應ASCII碼表中的c
}catch (Exception e){
e.printStackTrace();
}finally {//如果想要代碼一定會執(zhí)行，需要寫在finally中
try {
//5.關流操作
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}}寫入字符流的抽象類
常用方法:
Abstract void close() 關閉此流,但要先刷新它
Void write(char[ ] cbuf) 寫入字符數(shù)組
Void write(int c) 寫入單個字符
Void write(String str) 寫入字符串
Void write(String str,int off,int len) 寫入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)寫入字符數(shù)組的某一部分
用來寫入字符文件的便捷類,此類的構(gòu)造方法假定默認字符編碼和默認字節(jié)緩沖區(qū)大小都是可接受的.如果需要自己自定義這些值,可以先在FileOutputStream上構(gòu)造一個OutputStreamWriter.
構(gòu)造方法(創(chuàng)建對象):
FileWriter(String filename)
根據(jù)給定的文件名構(gòu)造一個FileWriter對象
FileWriter(String filename,boolean append)
根據(jù)給定的文件名以及指示是否附加寫入數(shù)據(jù)的boolean值來構(gòu)造FileWriter
將文本寫入字符輸出流,緩沖各個字符,從而提供單個字符,數(shù)組和字符串的高效寫入.可以指定緩沖區(qū)的大小,或者接受默認的大小,在大多數(shù)情況下,默認值就足夠大了
構(gòu)造方法(創(chuàng)建對象):
BufferedWriter(Writer out)
創(chuàng)建一個使用默認大小輸出緩沖區(qū)的緩沖字符輸出流
創(chuàng)建包: cn.tedu.file
創(chuàng)建類: TestOut2.java
package cn.tedu.file;import java.io.*;/*本類用于測試字符輸出流*/public class TestOut2 {
public static void main(String[] args) {
//method();//用于測試普通字符輸出流
method2();//用于測試高效字符輸出流
}
//創(chuàng)建一個用于測試高效字符輸出流的方法
private static void method2() {
//1.創(chuàng)建一個在本方法都生效的局部變量，值為null,注意手動初始化?。?！
Writer out = null;
//2.由于程序可能會拋出異常，所以需要寫一個try-catch-finally結(jié)構(gòu)
try{//存放可能會拋出異常的代碼
//3.創(chuàng)建普通字符輸出流對象
//out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
//out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
//4.使用流對象
out.write(100);
out.write(100);
out.write(100);
out.write(100);
out.write(100);
}catch (Exception e){//匹配并捕獲異常
e.printStackTrace();//如果捕獲到異常就打印錯誤信息
}finally {//一定會被執(zhí)行到的代碼塊，常用于關流
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//創(chuàng)建一個用于測試普通字符輸出流的方法
private static void method() {
//1.創(chuàng)建一個在本方法都生效的局部變量，值為null,注意手動初始化?。。?
Writer out = null;
//2.由于程序可能會拋出異常，所以需要寫一個try-catch-finally結(jié)構(gòu)
try{//存放可能會拋出異常的代碼
//3.創(chuàng)建普通字符輸出流對象
//out = new FileWriter(new File("E:\\ready\\2.txt"));
//out = new FileWriter("E:\\ready\\2.txt");
out = new FileWriter("E:\\ready\\2.txt",true);
//4.使用流對象
out.write(98);
out.write(98);
out.write(98);
out.write(98);
}catch (Exception e){//匹配并捕獲異常
e.printStackTrace();//如果捕獲到異常就打印錯誤信息
}finally {//一定會被執(zhí)行到的代碼塊，常用于關流
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}}通過學習以上的幾種流,我們也可以拓展嘗試做下文件的復制:
創(chuàng)建包: cn.tedu.file
創(chuàng)建類: TestCopyFile.java
package cn.tedu.file;import java.io.*;import java.util.Scanner;/*本類用于練習文件復制綜合案例*/public class TestCopyFile {
public static void main(String[] args) {
//1.提示并接收用戶輸入的兩個路徑
System.out.println("請輸入源文件路徑");//--被復制的那個文件
String f = new Scanner(System.in).nextLine();
System.out.println("請輸入新文件路徑：");//--復制好的新文件
String t = new Scanner(System.in).nextLine();
//2.調(diào)用創(chuàng)建好的自定義方法完成文件復制
//ZFCopy(f,t);//用字符流完成文件的復制案例
ZJCopy(f,t);//用字節(jié)流完成文件的復制案例
}
//利用字節(jié)流完成文件復制案例
private static void ZJCopy(String f, String t) {
//1.定義在整個方法都生效的局部變量，注意手動初始化，引用類型默認值為null
InputStream in = null;
OutputStream out = null;
//2.由于代碼可能會發(fā)生異常，所以需要編寫try-catch-finally結(jié)構(gòu)
try{
//3.1創(chuàng)建高效字節(jié)輸入流對象--FIS的參數(shù)是用戶傳入的源文件路徑f
in = new BufferedInputStream(new FileInputStream(f));
//3.2創(chuàng)建高效字節(jié)輸出流對象--FOS的參數(shù)是用戶傳入的新文件路徑t
out = new BufferedOutputStream(new FileOutputStream(t));
//4.利用創(chuàng)建好的流對象完成業(yè)務
//4.1定義變量用來保存讀到的數(shù)據(jù)
int b;
//4.2循環(huán)讀取源文件中的數(shù)據(jù)，只要不是-1，說明還有數(shù)據(jù)循環(huán)繼續(xù)
while((b = in.read()) != -1){
//4.3將讀到的數(shù)據(jù)寫入到新文件中
out.write(b);
}
System.out.println("恭喜您！文件復制成功！");
}catch (Exception e){
System.out.println("很抱歉！文件復制失??！");
e.printStackTrace();
}finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//利用字符流完成文件復制案例
private static void ZFCopy(String f, String t) {
//1.定義在整個方法中都生效的局部變量，注意手動初始化，默認值為null
Reader in = null;
Writer out = null;
//2.由于代碼可能會發(fā)生異常，所以需要編寫try-catch-finally結(jié)構(gòu)
try{
//3.1創(chuàng)建高效字符輸入流對象
in = new BufferedReader(new FileReader(f));
//3.2創(chuàng)建高效字符輸出流對象
out = new BufferedWriter(new FileWriter(t));
//4.拿到流對象以后，就可以使用流對象來完成業(yè)務了
//4.1定義變量用來保存讀到的數(shù)據(jù)
int b;
//4.2循環(huán)讀取源文件，直到返回值為-1，說明沒有數(shù)據(jù)了，再結(jié)束循環(huán)
while ((b=in.read())!=-1) {
//4.3將本輪循環(huán)中讀到的數(shù)據(jù)寫入到新文件中
out.write(b);
}
System.out.println("恭喜您！文件復制成功！");
}catch (Exception e){
System.out.println("很抱歉！文件復制失敗！");
e.printStackTrace();
}finally {
/*關流是有順序的：如果有多個流，最后創(chuàng)建的流最先關閉
* 多條關流語句需要各自try-catch*/
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}}1.主流分類
按照方向進行分類:輸入流 輸出流(相對于程序而言,從程序?qū)憯?shù)據(jù)到文件中是輸出)
按照傳輸類型進行分類:字節(jié)流 字符流
組合: 字節(jié)輸入流 字節(jié)輸出流 字符輸入流 字符輸出流
2.學習方法:在抽象父類中學習通用的方法,在子類中學習如何創(chuàng)建對象
3.字節(jié)輸入流:
InputStream 抽象類,不能new,可以作為超類,學習其所提供的共性方法--FileInputStream 子類,操作文件的字節(jié)輸入流,普通類 --BufferedInputStream 子類,緩沖字節(jié)輸入流,普通類
4.字符輸入流
Reader 抽象類,不能new,可以作為超類,學習其所提供的共性方法--FileReader,子類,操作文件的字符輸入流,普通類 --BufferedReader,子類,緩沖字符輸入流,普通類
5.字節(jié)輸出流:
OutputStream 抽象類,不能new,可以作為超類,學習其所提供的共性方法--FileOutputStream 子類,操作文件的字節(jié)輸出流,普通類 --BufferedOutputStream 子類,緩沖字節(jié)輸出流,普通類
6.字符輸出流
Writer 抽象類,不能new,可以作為超類,學習其所提供的共性方法--FileWriter,子類,操作文件的字符輸出流,普通類 --BufferedWriter,子類,緩沖字符輸出流,普通類
以上就是“JAVA的IO流、File、字節(jié)流及字符流實例分析”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注創(chuàng)新互聯(lián)行業(yè)資訊頻道。
