點我參考常用API：

IO圖解：

相關理論：

流的概念和作用：

　　流是一組有順序的，有起點和終點的位元組集合，是對資料傳輸的總稱或抽象。即資料在兩裝置間的傳輸稱為流，流的本質是資料傳輸，根據資料傳輸特性將流抽象為各種類，方便更直觀的進行資料操作。

IO流的分類：

　　根據處理資料型別的不同分為：字元流和位元組流

　　根據資料流向不同分為：輸入流和輸出流

字元流和位元組流：

　　字元流的由來： 因為資料編碼的不同，而有了對字元進行高效操作的流物件。本質其實就是基於位元組流讀取時，去查了指定的碼錶。

位元組流和字元流的區別：

讀寫單位不同：

　　位元組流以位元組（8bit）為單位，字元流以字元為單位，根據碼錶對映字元，一次可能讀多個位元組。

處理物件不同：

　　位元組流能處理所有型別的資料（如圖片、avi等），而字元流只能處理字元型別的資料。

位元組流：

　　一次讀入或讀出是8位二進位制。

字元流：

　　一次讀入或讀出是16位二進位制。

裝置上的資料無論是圖片或者視訊，文字，它們都以二進位制儲存的。二進位制的最終都是以一個8位為資料單元進行體現，所以計算機中的最小資料單元就是位元組。

意味著，位元組流可以處理裝置上的所有資料，所以位元組流一樣可以處理字元資料。

結論：只要是處理純文字資料，就優先考慮使用字元流。 除此之外都使用位元組流。

輸入流和輸出流：

　　輸入流只能進行讀操作，輸出流只能進行寫操作，程式中需要根據待傳輸資料的不同特性而使用不同的流。

輸入位元組流 InputStream：

　　InputStream：是所有的輸入位元組流的父類，它是一個抽象類。

　　ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三種基本的介質流，它們分別從Byte 陣列、StringBuffer、和本地檔案中讀取資料。

　　PipedInputStream：是從與其它執行緒共用的管道中讀取資料，與Piped 相關的知識後續單獨介紹。

　　ObjectInputStream：和所有 FilterInputStream 的子類都是裝飾流（裝飾器模式的主角）。

輸出位元組流 OutputStream：

　　OutputStream：是所有的輸出位元組流的父類，它是一個抽象類。

　　ByteArrayOutputStream、FileOutputStream 是兩種基本的介質流，它們分別向Byte 陣列、和本地檔案中寫入資料。

　　PipedOutputStream：是向與其它執行緒共用的管道中寫入資料。

　　ObjectOutputStream：和所有 FilterOutputStream 的子類都是裝飾流。

總結：

　　輸入流：InputStream或者Reader：從檔案中讀到程式中；

　　輸出流：OutputStream或者Writer：從程式中輸出到檔案中；

節點流：

節點流：直接與資料來源相連，讀入或讀出。

直接使用節點流，讀寫不方便，為了更快的讀寫檔案，才有了處理流。

這裡寫圖片描述：

常用的節點流：

父　類 ：InputStream 、OutputStream、 Reader、 Writer

文　件 ：FileInputStream 、 FileOutputStrean 、FileReader 、FileWriter 檔案進行處理的節點流

數　組 ：ByteArrayInputStream、 ByteArrayOutputStream、 CharArrayReader 、CharArrayWriter 對陣列進行處理的節點流（對應的不再是檔案，而是記憶體中的一個數組）

字串 ：StringReader、 StringWriter 對字串進行處理的節點流

管　道 ：PipedInputStream 、PipedOutputStream 、PipedReader 、PipedWriter 對管道進行處理的節點流

處理流：

處理流和節點流一塊使用，在節點流的基礎上，再套接一層，套接在節點流上的就是處理流。如BufferedReader.處理流的構造方法總是要帶一個其他的流物件做引數。

一個流物件經過其他流的多次包裝，稱為流的連結。

這裡寫圖片描述：

常用的處理流：

　　緩衝流：BufferedInputStrean 、BufferedOutputStream、 BufferedReader、 BufferedWriter 增加緩衝功能，避免頻繁讀寫硬碟。

　　轉換流：InputStreamReader 、OutputStreamReader實現位元組流和字元流之間的轉換。

　　資料流： DataInputStream 、DataOutputStream 等-提供將基礎資料型別寫入到檔案中，或者讀取出來。

轉換流：

　　InputStreamReader 、OutputStreamWriter 要InputStream或OutputStream作為引數，實現從位元組流到字元流的轉換。

建構函式：

　　InputStreamReader(InputStream)：//通過建構函式初始化，使用的是本系統預設的編碼表GBK。

　　InputStreamWriter(InputStream,String charSet)：//通過該建構函式初始化，可以指定編碼表。

　　OutputStreamWriter(OutputStream)：通過該建構函式初始化，使用的是本系統預設的編碼表GBK。

　　OutputStreamwriter(OutputStream,String charSet)：通過該建構函式初始化，可以指定編碼表。

1）：File檔案操作

建立檔案：

/**
     * 建立檔案
     */
    private static void createNewFile() {
        System.out.println("請你輸入檔案的名稱：預設（D:/）");
        String fileName = input.next();
        //建立File物件
        File file = new File("src\\FileText\\" + fileName);
        //判斷檔案是否存在
        if (file.exists()) {
            System.out.println("該檔案已存在！！！");
        } else {
            try {
                boolean flag = file.createNewFile();
                if (flag) {
                    System.out.println("成功建立");
                } else {
                    System.out.println("建立失敗！！！！");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

刪除檔案：

/**
     * 刪除檔案
     */
    private static void delFIle() {
        System.out.println("請你輸入要刪除檔案的名稱：預設（專案：FileText）");
        String fileName = input.next();
        //建立File物件
        File file = new File("src\\FileText\\" + fileName);
        if (file.exists()) {
            boolean flag = file.delete();
            if (flag) {
                System.out.println("刪除成功");
            } else {
                System.out.println("刪除失敗！！！！");
            }
        } else {
            System.out.println("該檔案不存在！！！");
        }
    }

修改檔案：

/**
     * 更新檔名
     */
    private static void updFile() {
        System.out.println("請你輸入要修改的檔案的名稱：預設（專案：FileText）");
        String oldfileName = input.next();
        System.out.println("請你輸入要新檔名稱：預設（專案：FileText）");
        String newfileName = input.next();
        //建立File物件
        File oldfile = new File("src\\FileText\\" + oldfileName);
        File onewfile = new File("src\\FileText\\" + newfileName);
        if (oldfile.renameTo(onewfile)) {
            System.out.println("更新成功");
        } else {
            System.out.println("更新失敗！！！");
        }
    }

建立資料夾：

/**
     * 建立資料夾
     */
    private static void mkdirss() {
        System.out.println("請你輸入要建立的資料夾名稱：預設（專案：FileText）");
        String fileName = input.next();
        //建立File物件
        File file = new File("src\\FileText\\" + fileName);
        //同時建立多級檔案file.mkdirs()
        //單個建立檔案file.mkdir()
        if (file.mkdirs()) {
            System.out.println("建立資料夾成功");
        } else {
            System.out.println("建立資料夾失敗！！！");
        }
    }

查詢資料夾下的檔案列表：

/**
     * 查詢資料夾下所有的檔案
     */
    private static void sleFile() {
        System.out.println("請你輸入要查詢的資料夾名稱：預設（專案：FileText）");
        //String fileName = input.next();
        //建立File物件
        File file = new File("src\\FileText\\" );
        //獲取陣列集合
        File[] files = file.listFiles();
        /***
         * 遍歷集合
         * countDic：檔案夾個數
         * countFile：檔案個數
         */
        int countDic = 0;
        int countFile = 0;
        for (File file1 : files) {
            //判斷資料夾
            if (file1.isDirectory()) {
                countDic++;
            }
            //判斷檔案
            if (file1.isFile()) {
                countFile++;
            }
        }
        System.out.println("資料夾共有：" + countDic);
        System.out.println("檔案共有：" + countFile);
    }

2）：操作 位元組流

public static void main(String[] args) {
        //建立輸入和輸出流物件
        InputStream inputStream=null;
        OutputStream outputStream=null;
        try {
            inputStream=new FileInputStream("src\\FileText\\fileText.txt");
            outputStream=new FileOutputStream("src\\FileText\\fileText.txt");
            //向檔案寫入
            outputStream.write("abc".getBytes());
            //迭代資料
            int num=0;
            StringBuffer sb=new StringBuffer();
            while ((num=inputStream.read())!=-1)
            {
                //子節轉字元
                sb.append((char)num);
            }
            System.out.println(sb.toString());
        }catch(Exception e)
        {
            e.printStackTrace();
        }finally {
            try {
                outputStream.close();
                inputStream.close();
            }catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }

3）：操作 字元流

/**
     * 字元流
     * Reader         Writer 基類
     * FileReader     FileWrider 子類
     */
    public static void main(String[] args) {
        //建立輸入輸出流
        Reader reader = null;
        Writer writer = null;
        try {
            reader = new FileReader("src\\FileText\\fileText.txt");
            //append:true,標識檔案末尾追加
            writer = new FileWriter("src\\FileText\\fileText.txt", true);
            //寫入資料
            writer.write("今天天氣不錯！！！");
            //重新整理緩衝區
            writer.flush();
            //讀取檔案
            //建立一次性讀取陣列
            char[] data = new char[1024];
            int num = 0;
            //拼接字串
            StringBuffer sb = new StringBuffer();
            while ((num = reader.read(data)) != -1) {
                sb.append(data, 0, data.length);
            }
            System.out.println(sb.toString());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {

                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

4）：操作 緩衝流 

    /**
     * 緩衝流
     * BufferReader BufferWriter  不單獨使用
     * 一般結合Reader 和 Wrider
     */
    public static void main(String[] args) {
        //建立輸入輸出流
        Reader reader = null;
        Writer writer = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            reader = new FileReader("src\\FileText\\fileText.txt");
            //append:true,標識檔案末尾追加
            writer = new FileWriter("src\\FileText\\fileText.txt");
            br = new BufferedReader(reader);
            bw = new BufferedWriter(writer);
            //寫入資料
            bw.write("今天很好！！！");
            bw.newLine();
            bw.write("今天很好嗎！！！");
            //重新整理緩衝區
            bw.flush();
            bw.close();
            //迭代資料
            StringBuffer sb = new StringBuffer();
            String temp = null;
            while ((temp = br.readLine()) != null) {
                sb.append(temp);
            }
            System.out.println(sb.toString());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                writer.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

5）：操作 二進位制流

 /**
     * 二進位制流
     * DataInputStream   DataOutputStream
     * 不單獨使用  一般結合 InputStream  OutPutStream 使用
     */
    public static void main(String[] args) {
        //建立輸入和輸出流物件
        InputStream inputStream = null;
        OutputStream outputStream = null;
        DataInputStream dis = null;
        DataOutputStream dos = null;
        try {
            inputStream = new FileInputStream("src\\FileText\\text.txt");
            outputStream = new FileOutputStream("src\\FileText\\abc.txt");
            dos = new DataOutputStream(outputStream);
            dis = new DataInputStream(inputStream);

            //獲取寫入
            int count = 0;
            while ((count = dis.read()) != -1) {
                dos.write(count);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                dos.close();
                outputStream.close();
                dis.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

6）：操作 序列化

/**
     * 序列化：把java中的物件持久化到檔案中 的過程
     * 反序列化：把檔案中儲存的資訊還原成java物件的過程
     * 想實現序列化，必須實現Serializable介面
     */
    public static void main(String[] args) {
        InputStream inputStream = null;
        OutputStream outputStream = null;
        ObjectInputStream objectInputStream = null;
        ObjectOutputStream objectOutputStream = null;
        try {
            inputStream = new FileInputStream("src\\FileText\\fileText.txt");
            outputStream = new FileOutputStream("src\\FileText\\fileText.txt");
            objectOutputStream = new ObjectOutputStream(outputStream);
            objectInputStream = new ObjectInputStream(inputStream);
            //序列化資訊
            TextUser info = new TextUser();
            info.setName("admin");
            objectOutputStream.writeObject(info);
            objectOutputStream.flush();
            objectOutputStream.close();
            //讀取序列化
            TextUser user = (TextUser) objectInputStream.readObject();
            System.out.println(user.getName() + "=========");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
    }

Face your past without regret. Handle your present with confidence.Prepare for future without fear. keep the faith and drop the fear.

面對過去無怨無悔，把握現在充滿信心，備戰未來無所畏懼。保持信念，克服恐懼！一點一滴的積累，一點一滴的沉澱，學技術需要不斷的積澱！