目錄

一.File類

1.1File類的概述與構造方法

1.1.1File類的介紹

1.2File類的常用方法

1.2.1File類的創建功能

1.2.2File類的判斷與獲取功能

1.2.3File類的洗掉功能

1.2.4絕對路徑與相對路徑

二 .IO流

2.1IO流介紹

2.2位元組流

2.2.1位元組流概述

2.2.2位元組輸出流FileOutputStream寫檔案

2.2.3位元組輸入流FileInputStream讀檔案

2.2.4位元組流復制圖片

2.2.5位元組緩沖流

2.3字符流

2.3.1字符流寫資料的方式

2.3.2字符流讀資料的方式

2.3.3字符流復制Java檔案改進版【應用】

2.3.4字符緩沖流

3.2標準輸出流

3.3位元組列印流

2.3.5字符緩沖流的特有功能

三.特殊操作流3.1.標準輸入流

3.4字符列印流

3.5物件序列化流

3.6物件反序列化流

四.Properties集合

4.1介紹

4.2特有方法

4.3Properties和IO流相結合的方法【應用】

4.3.1特有方法

五.IO流常見面試題

5.1IO流分為幾種

5.2位元組流字符流的區別

5.3什么是NIO

5.4什么是序列化和反序列化，實作物件序列化需要做哪些作業？

5.5RandomAccessFile

一.File類

1.1File類的概述與構造方法

1.1.1File類的介紹

（1）它是檔案和目錄路徑名的抽象表示

（2）檔案和目錄是可以通過File封裝成物件的

（3）對于File而言，其封裝的并不是一個真正存在的檔案，僅僅是一個路徑名而已，它可以是存在的，也可以是不存在的，將來是要通過具體的操作把這個路徑的內容轉換為具體存在的

1.1.2File類的構造方法

1.2File類的常用方法

1.2.1File類的創建功能

1.2.2File類的判斷與獲取功能

代碼演示：

public class FileDemo04 {
    public static void main(String[] args) {
        //創建一個File物件
        File f = new File("myFile\\java.txt");

//        public boolean isDirectory()：測驗此抽象路徑名表示的File是否為目錄
//        public boolean isFile()：測驗此抽象路徑名表示的File是否為檔案
//        public boolean exists()：測驗此抽象路徑名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

//        public String getAbsolutePath()：回傳此抽象路徑名的絕對路徑名字串
//        public String getPath()：將此抽象路徑名轉換為路徑名字串
//        public String getName()：回傳由此抽象路徑名表示的檔案或目錄的名稱
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

//        public String[] list()：回傳此抽象路徑名表示的目錄中的檔案和目錄的名稱字串陣列
//        public File[] listFiles()：回傳此抽象路徑名表示的目錄中的檔案和目錄的File物件陣列
        File f2 = new File("E:\\itcast");

        String[] strArray = f2.list();
        for(String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for(File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
}

1.2.3File類的洗掉功能

代碼演示：

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
//        File f1 = new File("E:\\itcast\\java.txt");
        //需求1：在當前模塊目錄下創建java.txt檔案
        File f1 = new File("myFile\\java.txt");
//        System.out.println(f1.createNewFile());

        //需求2：洗掉當前模塊目錄下的java.txt檔案
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在當前模塊目錄下創建itcast目錄
        File f2 = new File("myFile\\itcast");
//        System.out.println(f2.mkdir());

        //需求4：洗掉當前模塊目錄下的itcast目錄
        System.out.println(f2.delete());
        System.out.println("--------");

        //需求5：在當前模塊下創建一個目錄itcast,然后在該目錄下創建一個檔案java.txt
        File f3 = new File("myFile\\itcast");
//        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\itcast\\java.txt");
//        System.out.println(f4.createNewFile());

        //需求6：洗掉當前模塊下的目錄itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

1.2.4絕對路徑與相對路徑

絕對路徑和相對路徑的區別

• 絕對路徑：完整的路徑名，不需要任何其他資訊就可以定位它所表示的檔案，例如：E:\itcast\java.txt

• 相對路徑：必須使用取自其他路徑名的資訊進行解釋，例如：myFile\java.txt

二 .IO流

2.1IO流介紹

• IO流介紹

  • IO：輸入/輸出(Input/Output)

  • 流：是一種抽象概念，是對資料傳輸的總稱，也就是說資料在設備間的傳輸稱為流，流的本質是資料傳輸

  • IO流就是用來處理設備間資料傳輸問題的，常見的應用：檔案復制；檔案上傳；檔案下載

• IO流的分類

  • 按照資料的流向

    • 輸入流：讀資料

    • 輸出流：寫資料

  • 按照資料型別來分

    • 位元組流

      • 位元組輸入流

      • 位元組輸出流

    • 字符流

      • 字符輸入流

      • 字符輸出流

• IO流的使用場景

  • 如果操作的是純文本檔案，優先使用字符流

  • 如果操作的是圖片、視頻、音頻等二進制檔案，優先使用位元組流

  • 如果不確定檔案型別，優先使用位元組流，位元組流是萬能的流

2.2位元組流

2.2.1位元組流概述

• 位元組流抽象基類

  • InputStream：這個抽象類是表示位元組輸入流的所有類的超類

  • OutputStream：這個抽象類是表示位元組輸出流的所有類的超類

  • 子類名特點：子類名稱都是以其父類名作為子類名的后綴

• 位元組輸出流

  • FileOutputStream(String name)：創建檔案輸出流以指定的名稱寫入檔案

• 使用位元組輸出流寫資料的步驟

  • 創建位元組輸出流物件(呼叫系統功能創建了檔案，創建位元組輸出流物件，讓位元組輸出流物件指向檔案)

  • 呼叫位元組輸出流物件的寫資料方法

  • 釋放資源(關閉此檔案輸出流并釋放與此流相關聯的任何系統資源)

2.2.2位元組輸出流FileOutputStream寫檔案

寫資料的方法分類

代碼演示：

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //FileOutputStream(String name)：創建檔案輸出流以指定的名稱寫入檔案
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        //new File(name)
//        FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));

        //FileOutputStream(File file)：創建檔案輸出流以寫入由指定的 File物件表示的檔案
//        File file = new File("myByteStream\\fos.txt");
//        FileOutputStream fos2 = new FileOutputStream(file);
//        FileOutputStream fos2 = new FileOutputStream(new File("myByteStream\\fos.txt"));

        //void write(int b)：將指定的位元組寫入此檔案輸出流
//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);

//        void write(byte[] b)：將 b.length位元組從指定的位元組陣列寫入此檔案輸出流
//        byte[] bys = {97, 98, 99, 100, 101};
        //byte[] getBytes()：回傳字串對應的位元組陣列
        byte[] bys = "abcde".getBytes();
//        fos.write(bys);

        //void write(byte[] b, int off, int len)：將 len位元組從指定的位元組陣列開始，從偏移量off開始寫入此檔案輸出流
//        fos.write(bys,0,bys.length);
        fos.write(bys,1,3);

        //釋放資源
        fos.close();
    }
}

2.2.3位元組輸入流FileInputStream讀檔案

• 位元組輸入流

  • FileInputStream(String name)：通過打開與實際檔案的連接來創建一個FileInputStream ，該檔案由檔案系統中的路徑名name命名

• 位元組輸入流讀取資料的步驟

  • 創建位元組輸入流物件

  • 呼叫位元組輸入流物件的讀資料方法

• 釋放資源
  
  代碼演示：
  
  

  public class FileInputStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //創建位元組輸入流物件
          //FileInputStream(String name)
          FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
  
          int by;
          /*
              fis.read()：讀資料
              by=fis.read()：把讀取到的資料賦值給by
              by != -1：判斷讀取到的資料是否是-1
           */
          while ((by=fis.read())!=-1) {
              System.out.print((char)by);
          }
  
          //釋放資源
          fis.close();
      }
  }

  2.2.4位元組流復制圖片

• 案例需求

  把“E:\itcast\mn.jpg”復制到模塊目錄下的“mn.jpg”

• 實作步驟

  • 根據資料源創建位元組輸入流物件

  • 根據目的地創建位元組輸出流物件

  • 讀寫資料，復制圖片(一次讀取一個位元組陣列，一次寫入一個位元組陣列)

  • 釋放資源

  • 代碼實作：

• public class CopyJpgDemo {
      public static void main(String[] args) throws IOException {
          //根據資料源創建位元組輸入流物件
          FileInputStream fis = new FileInputStream("E:\\itcast\\mn.jpg");
          //根據目的地創建位元組輸出流物件
          FileOutputStream fos = new FileOutputStream("myByteStream\\mn.jpg");
  
          //讀寫資料，復制圖片(一次讀取一個位元組陣列，一次寫入一個位元組陣列)
          byte[] bys = new byte[1024];
          int len;
          while ((len=fis.read(bys))!=-1) {
              fos.write(bys,0,len);
          }
  
          //釋放資源
          fos.close();
          fis.close();
      }
  }

  
  2.2.5位元組緩沖流
  
  

• 位元組緩沖流介紹

  • BufferOutputStream：該類實作緩沖輸出流， 通過設定這樣的輸出流，應用程式可以向底層輸出流寫入位元組，而不必為寫入的每個位元組導致底層系統的呼叫

  • BufferedInputStream：創建BufferedInputStream將創建一個內部緩沖區陣列， 當從流中讀取或跳過位元組時，內部緩沖區將根據需要從所包含的輸入流中重新填充，一次很多位元組

• 構造方法：

  方法名	說明
  BufferedOutputStream(OutputStream out)	創建位元組緩沖輸出流物件
  BufferedInputStream(InputStream in)	創建位元組緩沖輸入流物件

  代碼演示：
  

  public class BufferStreamDemo {
      public static void main(String[] args) throws IOException {
          //位元組緩沖輸出流：BufferedOutputStream(OutputStream out)
   
          BufferedOutputStream bos = new BufferedOutputStream(new 				                                       FileOutputStream("myByteStream\\bos.txt"));
          //寫資料
          bos.write("hello\r\n".getBytes());
          bos.write("world\r\n".getBytes());
          //釋放資源
          bos.close();
      
  
          //位元組緩沖輸入流：BufferedInputStream(InputStream in)
          BufferedInputStream bis = new BufferedInputStream(new                                                          FileInputStream("myByteStream\\bos.txt"));
  
          //一次讀取一個位元組資料
  //        int by;
  //        while ((by=bis.read())!=-1) {
  //            System.out.print((char)by);
  //        }
  
          //一次讀取一個位元組陣列資料
          byte[] bys = new byte[1024];
          int len;
          while ((len=bis.read(bys))!=-1) {
              System.out.print(new String(bys,0,len));
          }
  
          //釋放資源
          bis.close();
      }
  }

  2.3字符流
  
  

• 字符流的介紹

  由于位元組流操作中文不是特別的方便，所以Java就提供字符流

  字符流 = 位元組流 + 編碼表

• 中文的位元組存盤方式

  用位元組流復制文本檔案時，文本檔案也會有中文，但是沒有問題，原因是最終底層操作會自動進行位元組拼接成中文，如何識別是中文的呢？

  漢字在存盤的時候，無論選擇哪種編碼存盤，第一個位元組都是負數

代碼演示：

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定義一個字串
        String s = "中國";

        //byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
        //byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
        byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        //String ss = new String(bys);
        //String ss = new String(bys,"UTF-8");
        String ss = new String(bys,"GBK");
        System.out.println(ss);
    }
}

• 字符流中和編碼解碼問題相關的兩個類

  • InputStreamReader：是從位元組流到字符流的橋梁

    它讀取位元組，并使用指定的編碼將其解碼為字符

    它使用的字符集可以由名稱指定，也可以被明確指定，或者可以接受平臺的默認字符集

  • OutputStreamWriter：是從字符流到位元組流的橋梁

    是從字符流到位元組流的橋梁，使用指定的編碼將寫入的字符編碼為位元組

    它使用的字符集可以由名稱指定，也可以被明確指定，或者可以接受平臺的默認字符集

• 構造方法

  方法名	說明
  InputStreamReader(InputStream in)	使用默認字符編碼創建InputStreamReader物件
  InputStreamReader(InputStream in,String chatset)	使用指定的字符編碼創建InputStreamReader物件
  OutputStreamWriter(OutputStream out)	使用默認字符編碼創建OutputStreamWriter物件
  OutputStreamWriter(OutputStream out,String charset)	使用指定的字符編碼創建OutputStreamWriter物件

2.3.1字符流寫資料的方式

• 方法介紹

  方法名	說明
  void write(int c)	寫一個字符
  void write(char[] cbuf)	寫入一個字符陣列
  void write(char[] cbuf, int off, int len)	寫入字符陣列的一部分
  void write(String str)	寫一個字串
  void write(String str, int off, int len)	寫一個字串的一部分

• 重繪和關閉的方法

  方法名	說明
  flush()	重繪流，之后還可以繼續寫資料
  close()	關閉流，釋放資源，但是在關閉之前會先重繪流，一旦關閉，就不能再寫資料

2.3.2字符流讀資料的方式

方法介紹

代碼：

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
   
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));

        //int read()：一次讀一個字符資料
//        int ch;
//        while ((ch=isr.read())!=-1) {
//            System.out.print((char)ch);
//        }

        //int read(char[] cbuf)：一次讀一個字符陣列資料
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        //釋放資源
        isr.close();
    }
}

2.3.3字符流復制Java檔案改進版【應用】

• 案例需求

  使用便捷流物件，把模塊目錄下的“ConversionStreamDemo.java” 復制到模塊目錄下的“Copy.java”

• 實作步驟

  • 根據資料源創建字符輸入流物件

  • 根據目的地創建字符輸出流物件

  • 讀寫資料，復制檔案

  • 釋放資源

代碼：

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根據資料源創建字符輸入流物件
        FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
        //根據目的地創建字符輸出流物件
        FileWriter fw = new FileWriter("myCharStream\\Copy.java");

        //讀寫資料，復制檔案
//        int ch;
//        while ((ch=fr.read())!=-1) {
//            fw.write(ch);
//        }

        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1) {
            fw.write(chs,0,len);
        }

        //釋放資源
        fw.close();
        fr.close();
    }
}

2.3.4字符緩沖流

3.2標準輸出流

3.3位元組列印流

• 字符緩沖流介紹

  • BufferedWriter：將文本寫入字符輸出流，緩沖字符，以提供單個字符，陣列和字串的高效寫入，可以指定緩沖區大小，或者可以接受默認大小，默認值足夠大，可用于大多數用途

  • BufferedReader：從字符輸入流讀取文本，緩沖字符，以提供字符，陣列和行的高效讀取，可以指定緩沖區大小，或者可以使用默認大小， 默認值足夠大，可用于大多數用途

• 構造方法

  方法名	說明
  BufferedWriter(Writer out)	創建字符緩沖輸出流物件
  BufferedReader(Reader in)	創建字符緩沖輸入流物件

  
  代碼：

  public class BufferedStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //BufferedWriter(Writer out)
          BufferedWriter bw = new BufferedWriter(new                                                            FileWriter("myCharStream\\bw.txt"));
          bw.write("hello\r\n");
          bw.write("world\r\n");
          bw.close();
  
          //BufferedReader(Reader in)
          BufferedReader br = new BufferedReader(new                                                           FileReader("myCharStream\\bw.txt"));
  
          //一次讀取一個字符資料
  //        int ch;
  //        while ((ch=br.read())!=-1) {
  //            System.out.print((char)ch);
  //        }
  
          //一次讀取一個字符陣列資料
          char[] chs = new char[1024];
          int len;
          while ((len=br.read(chs))!=-1) {
              System.out.print(new String(chs,0,len));
          }
  
          br.close();
      }
  }

  2.3.5字符緩沖流的特有功能
  

  方法介紹

  BufferedWriter：

  方法名	說明
  void newLine()	寫一行行分隔符，行分隔符字串由系統屬性定義

  BufferedReader:

  方法名	說明
  String readLine()	讀一行文字， 結果包含行的內容的字串，不包括任何行終止字符如果流的結尾已經到達，則為null

  代碼：

  public class BufferedStreamDemo02 {
      public static void main(String[] args) throws IOException {
  
          //創建字符緩沖輸出流
          BufferedWriter bw = new BufferedWriter(new                                                          FileWriter("myCharStream\\bw.txt"));
  
          //寫資料
          for (int i = 0; i < 10; i++) {
              bw.write("hello" + i);
              //bw.write("\r\n");
              bw.newLine();
              bw.flush();
          }
  
          //釋放資源
          bw.close();
  
          //創建字符緩沖輸入流
          BufferedReader br = new BufferedReader(new                                                          FileReader("myCharStream\\bw.txt"));
  
          String line;
          while ((line=br.readLine())!=null) {
              System.out.println(line);
          }
  
          br.close();
      }
  }

  
  三.特殊操作流
  3.1.標準輸入流
  

  System類中有兩個靜態的成員變數

• public static final InputStream in：標準輸入流，通常該流對應于鍵盤輸入或由主機環境或用戶指定的另一個輸入源

• public static final PrintStream out：標準輸出流，通常該流對應于顯示輸出或由主機環境或用戶指定的另一個輸出目標

• System類中有兩個靜態的成員變數

  • public static final InputStream in：標準輸入流，通常該流對應于鍵盤輸入或由主機環境或用戶指定的另一個輸入源

  • public static final PrintStream out：標準輸出流，通常該流對應于顯示輸出或由主機環境或用戶指定的另一個輸出目標

• 輸出陳述句的本質：是一個標準的輸出流

  • PrintStream ps = System.out;

  • PrintStream類有的方法，System.out都可以使用

• 列印流分類

  • 位元組列印流：PrintStream

  • 字符列印流：PrintWriter

• 列印流的特點

  • 只負責輸出資料，不負責讀取資料

  • 永遠不會拋出IOException

  • 有自己的特有方法

• 位元組列印流

  • PrintStream(String fileName)：使用指定的檔案名創建新的列印流

  • 使用繼承父類的方法寫資料，查看的時候會轉碼；使用自己的特有方法寫資料，查看的資料原樣輸出

  • 可以改變輸出陳述句的目的地

    public static void setOut(PrintStream out)：重新分配“標準”輸出流

3.4字符列印流

字符列印流構造房方法

3.5物件序列化流

• 物件序列化介紹

  • 物件序列化：就是將物件保存到磁盤中，或者在網路中傳輸物件

  • 這種機制就是使用一個位元組序串列示一個物件，該位元組序列包含：物件的型別、物件的資料和物件中存盤的屬性等資訊

  • 位元組序列寫到檔案之后，相當于檔案中持久保存了一個物件的資訊

  • 反之，該位元組序列還可以從檔案中讀取回來，重構物件，對它進行反序列化

• 物件序列化流： ObjectOutputStream

  • 將Java物件的原始資料型別和圖形寫入OutputStream， 可以使用ObjectInputStream讀取（重構）物件， 可以通過使用流的檔案來實作物件的持久存盤， 如果流是網路套接字流，則可以在另一個主機上或另一個行程中重構物件

• 構造方法

  方法名	說明
  ObjectOutputStream(OutputStream out)	創建一個寫入指定的OutputStream的ObjectOutputStream

• 序列化物件的方法

  方法名	說明
  void writeObject(Object obj)	將指定的物件寫入ObjectOutputStream

注意事項

• 一個物件要想被序列化，該物件所屬的類必須必須實作Serializable 介面

• Serializable是一個標記介面，實作該介面，不需要重寫任何方法

3.6物件反序列化流

• 物件反序列化流： ObjectInputStream

  • ObjectInputStream反序列化先前使用ObjectOutputStream撰寫的原始資料和物件

• 構造方法

  方法名	說明
  ObjectInputStream(InputStream in)	創建從指定的InputStream讀取的ObjectInputStream

• 反序列化物件的方法

  方法名	說明
  Object readObject()	從ObjectInputStream讀取一個物件

代碼：

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in)：創建從指定的InputStream讀取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));

        //Object readObject()：從ObjectInputStream讀取一個物件
        Object obj = ois.readObject();

        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());

        ois.close();
    }
}

四.Properties集合

4.1介紹

Properties介紹

• 是一個Map體系的集合類

• Properties可以保存到流中或從流中加載

• 屬性串列中的每個鍵及其對應的值都是一個字串

4.2特有方法

代碼：

public class PropertiesDemo02 {
    public static void main(String[] args) {
        //創建集合物件
        Properties prop = new Properties();

        //Object setProperty(String key, String value)：設定集合的鍵和值，都是String型別，底層呼叫Hashtable方法put
        prop.setProperty("itheima001", "林青霞");
        /*
            Object setProperty(String key, String value) {
                return put(key, value);
            }

            Object put(Object key, Object value) {
                return map.put(key, value);
            }
         */
        prop.setProperty("itheima002", "張曼玉");
        prop.setProperty("itheima003", "王祖賢");

        //String getProperty(String key)：使用此屬性串列中指定的鍵搜索屬性
//        System.out.println(prop.getProperty("itheima001"));
//        System.out.println(prop.getProperty("itheima0011"));

//        System.out.println(prop);

        //Set<String> stringPropertyNames()：從該屬性串列中回傳一個不可修改的鍵集，其中鍵及其對應的值是字串
        Set<String> names = prop.stringPropertyNames();
        for (String key : names) {
//            System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key + "," + value);
        }
    }
}

4.3Properties和IO流相結合的方法【應用】

4.3.1特有方法

和IO流結合的方法

代碼：

public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        //把集合中的資料保存到檔案
//        myStore();

        //把檔案中的資料加載到集合
        myLoad();

    }

    private static void myLoad() throws IOException {
        Properties prop = new Properties();

        //void load(Reader reader)：
        FileReader fr = new FileReader("myOtherStream\\fw.txt");
        prop.load(fr);
        fr.close();

        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("itheima001","林青霞");
        prop.setProperty("itheima002","張曼玉");
        prop.setProperty("itheima003","王祖賢");

        //void store(Writer writer, String comments)：
        FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}

五.IO流常見面試題
5.1IO流分為幾種

1.按照流的流向分，可以分為輸入流和輸出流；
2.按照操作單元劃分，可以劃分為位元組流和字符流；
3.按照流的角色劃分為節點流和處理流，
Java Io流共涉及40多個類，這些類看上去很雜亂，但實際上很有規則，而且彼此之間存在非常緊密的聯系， Java I0流的40多個類都是從如下4個抽象類基類中派生出來的，

InputStream/Reader: 所有的輸入流的基類，前者是位元組輸入流，后者是字符輸入流，
OutputStream/Writer: 所有輸出流的基類，前者是位元組輸出流，后者是字符輸出流

5.2位元組流字符流的區別

要把一片二進制資料資料逐一輸出到某個設備中，或者從某個設備中逐一讀取一片二進制資料，不管輸入輸出設備是什么，我們要用統一的方式來完成這些操作，用一種抽象的方式進行描述，這個抽象描述方式起名為IO流，對應的抽象類為OutputStream和InputStream ，不同的實作類就代表不同的輸入和輸出設備，它們都是針對位元組進行操作的，

在應用中，經常要完全是字符的一段文本輸出去或讀進來，用位元組流可以嗎？
計算機中的一切最終都是二進制的位元組形式存在，對于“中國”這些字符，首先要得到其對應的位元組，然后將位元組寫入到輸出流，讀取時，首先讀到的是位元組，可是我們要把它顯示為字符，我們需要將位元組轉換成字符，由于這樣的需求很廣泛，人家專門提供了字符流的包裝類，

底層設備永遠只接受位元組資料，有時候要寫字串到底層設備，需要將字串轉成位元組再進行寫入，字符流是位元組流的包裝，字符流則是直接接受字串，它內部將串轉成位元組，再寫入底層設備，這為我們向IO設別寫入或讀取字串提供了一點點方便，

5.3什么是NIO

看了一些文章，傳統的IO流是阻塞式的，會一直監聽一個ServerSocket，在呼叫read等方法時，他會一直等到資料到來或者緩沖區已滿時才回傳，呼叫accept也是一直阻塞到有客戶端連接才會回傳，每個客戶端連接過來后，服務端都會啟動一個執行緒去處理該客戶端的請求，并且多執行緒處理多個連接，每個執行緒擁有自己的堆疊空間并且占用一些 CPU 時間，每個執行緒遇到外部未準備好的時候，都會阻塞掉，阻塞的結果就是會帶來大量的行程背景關系切換，
對于NIO，它是非阻塞式，核心類：
1.Buffer為所有的原始型別提供 (Buffer)快取支持，
2.Charset字符集編碼解碼解決方案
3.Channel一個新的原始 I/O抽象，用于讀寫Buffer型別，通道可以認為是一種連接，可以是到特定設備，程式或者是網路的連接，

5.4什么是序列化和反序列化，實作物件序列化需要做哪些作業？

物件序列化是將物件以二進制的形式保存在硬碟上或者傳輸到網路；而反序列化則是將二進制的檔案轉化為物件讀取，
Jre本身就提供了序列化支持，我們可以調OutputStream的writeObject方法來做，如果要讓java 幫我們做，要被傳輸的物件必須實作serializable介面，這樣，javac編譯時就會進行特殊處理，編譯的類才可以被writeObject方法操作，這就是所謂的序列化，

serializable介面是一個mini介面，其中沒有需要實作的方法，implements Serializable只是為了標注該物件是可被序列化的，
如果不想讓欄位放在硬碟上就加transient，

5.5RandomAccessFile

它在java.io包中是一個特殊的類，既不是輸入流也不是輸出流，它兩者都可以做到，他是Object的直接子類，通常來說，一個流只有一個功能，要么讀，要么寫，但是RandomAccessFile既可以讀檔案，也可以寫檔案，DataInputStream和DataOutStream有的方法，在RandomAccessFile都存在