JAVA的IO流、File、字節(jié)流及字符流實例分析

今天小編給大家分享一下JAVA的IO流、File、字節(jié)流及字符流實例分析的相關知識點，內(nèi)容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

IO簡介

1 Stream

在學習IO流之前,我們首先需要學習的概念就是Stream流
為了方便理解,我們可以把數(shù)據(jù)的讀寫操作抽象成數(shù)據(jù)在"管道"中流動,但需注意:
1.流只能單方向流動
2.輸入流用來讀取 → in
3.輸出流用來寫出 → out
4.數(shù)據(jù)只能從頭到尾順序的讀寫一次
所以以程序的角度來思考,In/out 相對于程序而言的輸入(讀取)/輸出(寫出)的過程.

2 IO流的繼承結構

在java中,根據(jù)處理的數(shù)據(jù)單位不同,可以把流分為字節(jié)流和字符流
字節(jié)流 : 針對二進制文件
字符流 : 針對文本文件
再結合對應類型的輸入和輸出方向,常用的流有:

File

字節(jié)流:針對二進制文件

InputStream

FileInputStream

BufferedInputStream

ObjectInputStream

OutputStream

FileOutputStream

BufferedOutputStream

ObjectOutputStream

字符流:針對文本文件

Reader

FileReader

BufferedReader

InputStreamReader

Writer

FileWriter

BufferedWriter

OutputStreamWriter

PrintWriter一行行寫出

3 File文件類

3.1概述

封裝一個磁盤路徑字符串,對這個路徑可以執(zhí)行一次操作
可以封裝文件路徑、文件夾路徑、不存在的路徑

3.2創(chuàng)建對象

File(String pathname)通過將給定路徑名字符串轉換為抽象路徑名來創(chuàng)建一個新的File實例
new File(“d:/abc/a.txt”);
new File(“d:/abc”,”a.txt”);

3.3常用方法

3.4 練習：測試常用方法

創(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());
    }}

4 字節(jié)流讀取

字節(jié)流是由字節(jié)組成的,字符流是由字符組成的.
Java里字符由兩個字節(jié)組成.字節(jié)流是基本流，主要用在處理二進制數(shù)據(jù)。
所以字節(jié)流是比較常用的，可以可以處理多種不同種類的文件，比如文本文檔/音頻/視頻等等

4.1 InputStream抽象類

此抽象類是表示字節(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)資源

4.2 FileInputStream子類

直接插在文件上，直接讀取文件數(shù)據(jù)

創(chuàng)建對象
FileInputStream(File file)—直接傳文件對象
通過打開一個到實際文件的連接來創(chuàng)建一個 FileInputStream，該文件通過文件系統(tǒng)中的 File 對象 file 指定FileInputStream(String pathname)—傳路徑
通過打開一個到實際文件的連接來創(chuàng)建一個 FileInputStream，該文件通過文件系統(tǒng)中的路徑名 name 指定

4.3 BufferedInputStream子類

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，以便將來使用。

4.4 練習：字節(jié)流讀取案例

創(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結構中的第三個部分：finally{}
        * 這部分不論是否捕獲到異常，是一定會被執(zhí)行到的代碼，常用于關流*/
        }finally {
            try {
                //3.釋放資源，流資源用完必須釋放！?。?
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }}

5 字符流讀取

常用于處理純文本數(shù)據(jù),讀寫容易出現(xiàn)亂碼的現(xiàn)象,在讀寫時,最好指定編碼集為UTF-8

5.1 Reader抽象類

用于讀取字符流的抽象類。

常用方法：
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)的所有資源

5.2 FileReader子類

用來讀取字符文件的便捷類。此類的構造方法假定默認字符編碼和默認字節(jié)緩沖區(qū)大小都是適當?shù)?。要自己指定這些值，可以先在 FileInputStream 上構造一個 InputStreamReader。

創(chuàng)建對象
FileReader(String fileName) 在給定從中讀取數(shù)據(jù)的文件名的情況下創(chuàng)建一個新 FileReader
FileReader(File file) 在給定從中讀取數(shù)據(jù)的 File 的情況下創(chuàng)建一個新 FileReader

5.3 BufferedReader子類

從字符輸入流中讀取文本，緩沖各個字符，從而實現(xiàn)字符、數(shù)組和行的高效讀取。
可以指定緩沖區(qū)的大小，或者可使用默認的大小。大多數(shù)情況下，默認值就足夠大了。

創(chuàng)建對象
BufferedReader(Reader in) 創(chuàng)建一個使用默認大小輸入緩沖區(qū)的緩沖字符輸入流

5.4 練習：字符流讀取案例

創(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();
            }
        }
    }}

6 字節(jié)流寫出

6.1 OutputStream抽象類

此抽象類是表示輸出字節(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é)寫入此輸出流

6.2 FileOutputStream 子類

直接插在文件上,直接寫出文件數(shù)據(jù)

構造方法(創(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)容

6.3 BufferedOutputstream 子類

該類實現(xiàn)緩沖的輸出流,通過設置這種輸出流,應用程序就可以將各個字節(jié)寫入底層輸出流中,而不必每次針對字節(jié)寫出調(diào)用底層系統(tǒng)

構造方法(創(chuàng)建對象):
BufferedOutputStream(OutputStream out)
創(chuàng)建一個新的緩沖輸出流,用以將數(shù)據(jù)寫入指定的底層輸出流

6.4 練習: 字節(jié)輸出流測試:

創(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結構，因為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();
            }
        }
    }}

7 字符流寫出

7.1 Writer 抽象類

寫入字符流的抽象類

常用方法:
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ù)組的某一部分

7.2 FileWriter 子類

用來寫入字符文件的便捷類,此類的構造方法假定默認字符編碼和默認字節(jié)緩沖區(qū)大小都是可接受的.如果需要自己自定義這些值,可以先在FileOutputStream上構造一個OutputStreamWriter.

構造方法(創(chuàng)建對象):
FileWriter(String filename)
根據(jù)給定的文件名構造一個FileWriter對象
FileWriter(String filename,boolean append)
根據(jù)給定的文件名以及指示是否附加寫入數(shù)據(jù)的boolean值來構造FileWriter

7.3 BufferedWriter子類

將文本寫入字符輸出流,緩沖各個字符,從而提供單個字符,數(shù)組和字符串的高效寫入.可以指定緩沖區(qū)的大小,或者接受默認的大小,在大多數(shù)情況下,默認值就足夠大了

構造方法(創(chuàng)建對象):
BufferedWriter(Writer out)
創(chuàng)建一個使用默認大小輸出緩沖區(qū)的緩沖字符輸出流

7.4 練習: 字符輸出流測試:

創(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結構
        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結構
        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();
            }
        }
    }}

8 拓展

通過學習以上的幾種流,我們也可以拓展嘗試做下文件的復制:
創(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結構
        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結構
        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ù)了，再結束循環(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();
            }
        }

    }}

9 總結:IO的繼承結構

1.主流分類

1. 按照方向進行分類:輸入流 輸出流(相對于程序而言,從程序寫數(shù)據(jù)到文件中是輸出)

2. 按照傳輸類型進行分類:字節(jié)流 字符流

3. 組合: 字節(jié)輸入流 字節(jié)輸出流 字符輸入流 字符輸出流

2.學習方法:在抽象父類中學習通用的方法,在子類中學習如何創(chuàng)建對象
3.字節(jié)輸入流:

--FileInputStream 子類,操作文件的字節(jié)輸入流,普通類
--BufferedInputStream 子類,緩沖字節(jié)輸入流,普通類

4.字符輸入流

--FileReader,子類,操作文件的字符輸入流,普通類
--BufferedReader,子類,緩沖字符輸入流,普通類

5.字節(jié)輸出流:

--FileOutputStream 子類,操作文件的字節(jié)輸出流,普通類
--BufferedOutputStream 子類,緩沖字節(jié)輸出流,普通類

6.字符輸出流

--FileWriter,子類,操作文件的字符輸出流,普通類
--BufferedWriter,子類,緩沖字符輸出流,普通類

以上就是“JAVA的IO流、File、字節(jié)流及字符流實例分析”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業(yè)資訊頻道。