MySQL資料庫之資料庫備份與還原

阿新 • • 發佈：2020-12-15

IO概述
什麼是IO？

Java中IO的操作主要是靠“java.io”包下面的內和介面實現的，進行輸入，輸出操作。輸入也可以叫做讀取資料，輸出也可以叫做寫入資料。

IO分類

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

輸入流：把資料從其他裝置上讀取到記憶體當中的流
輸出流：把資料從記憶體當中寫入到其他裝置上的流

IO流的頂級父類

輸入流輸出流

位元組流位元組輸入流InputStream 位元組輸出流OutputStream

字元流字元輸入流Reader 字元輸出流Writer

位元組流

一切皆為位元組

一切檔案資料(文字文件，圖片，視訊等)在儲存時，都是以二進位制數字的形式儲存的，都是一個一個的位元組，那麼資料在進行傳輸的時候也是如此。所以位元組流可以傳輸任意檔案的資料。在操作流的時候，我們要明確，無論使用了什麼樣的流物件，底層傳輸的始終為二進位制資料。

位元組輸出流OutputStream

“java.io.OutputStream”此抽象類是表示輸出位元組流的所有類的超類,將指定的位元組資訊寫入到目的地。它定義了位元組輸出流的基本共性的API方法：
- public void close();關閉此輸出流並釋放與此流相關的其他任何系統資源
- public void flush(); 重新整理此輸出流並強制任何緩衝的輸出位元組資訊被寫入。
- public void write(byte[] b);將b.length位元組從指定的位元組陣列寫入到此輸出流中
- public void write(byte[] b,off,int len);從指定的位元組陣列寫入len個位元組，從偏移量off開始輸出到此輸出流中
- public abstract void write(int b);將指定的位元組輸出到此輸出流中

	輸入流	輸出流
位元組流	位元組輸入流InputStream	位元組輸出流OutputStream
字元流	字元輸入流Reader	字元輸出流Writer

備註:close方法，當完成流的操作時，必須呼叫此方法，釋放系統資源。

FileOutputStream類

“java.io.FileOutputStream”類是檔案位元組輸出流，用於將資料寫入到檔案中。

構造方法

public FileOutputStream(File file);建立一個向指定 File 物件表示的檔案中寫入資料的檔案輸出流。
public FileOutputStream(String name);建立檔案輸出流以指定的檔名稱寫入檔案中。

當你建立一個流物件時，必須先去傳遞一個檔案路徑，該路徑下，如果沒用這個檔案，會建立該檔案，如果有這個檔案，會清空這個檔案當中的資料。

示例程式碼：

public class Demo01FileOutputStream {

    public static void main(String[] args) throws IOException {
        //1.建立一個FileOutputStream類物件，構造方法中傳遞寫入資料的目的地。
        FileOutputStream f = new FileOutputStream("a.txt");
        //2.呼叫FileOutputStream物件中的方法write，把資料寫入到檔案中
        f.write(97);
        //3.釋放資源
        f.close();
    }


}

資料的追加續寫

如何在保留目標檔案中的資料，還能繼續新增新的資料到目標檔案中？

public FileOutputStream(File file,boolean append);建立檔案輸出流以寫入由指定的File物件為檔案中。
public FileOutputStream(String name,boolean append);建立檔案輸出流以指定的名稱寫入檔案中

這兩個構造方法，引數中都需要傳入一個boolean型別的值，true表示的追加資料，false表示的清空原有資料這樣的清空下建立輸出流物件，就可以指定是否需要在檔案的末尾追加。

程式碼演示：
```
public static void main(String[] args) throws IOException {
     //1。建立物件
        FileOutputStream fos = new FileOutputStream("c.txt", false);
     //2.呼叫write()
        fos.write("HelloWorld".getBytes());
       //3.關閉流物件
       fos.close();
    }
```
寫入換行

Windows系統裡，換行符是\r\n。把以指定是否需要追加續寫換行。

Linux系統中，換行符號是/n

mac系統裡，換行符號是/r

Unix系統裡，每行結尾只有換行，即\n

回車符\r和換行符\n
- 回車符：回到一行的開頭()
- 換行符：下一行(newLine)
  
  系統中的換行：
  - windows系統中，每行結尾是“回車+換行”。即\r\n.
  - Unix系統中，每行結尾只有換行，即/n
  - Mac系統中，每行的結尾是回車，即/r
```
public class Demo03FileOutputStream {

    public static void main(String[] args) throws IOException {
     //1。建立物件
        FileOutputStream fos = new FileOutputStream("c.txt", true);
     //2.呼叫write()
        fos.write("\n".getBytes());
        fos.write("Java31".getBytes());
        //實現資料換行
       //3.關閉流物件
       fos.close();
    }


}
```
位元組輸入流InputStream

“java.io.InputStream”此抽象類是表示位元組輸入流的所有類的超類。可以讀取位元組資訊到記憶體中，它定義了位元組輸入流的基本共性的API方法：
- public void close();關閉此輸入流，並釋放與此流相關的其他的任何系統資源
- public abstract int read();從輸入流中讀取資料的下一個位元組。
- public int read(byte[] b):從輸入流中讀取一些位元組數，並將它們儲存到位元組陣列b當中(int返回的位元組數量)。
  
  備註：close方法，當完成流的相關操作後，需要呼叫此方法關閉輸入流，釋放系統資源。
  
  FileInputStream類
  
  “java.io.FileInputStream”類是檔案輸入流，從檔案中讀取位元組。
  
  構造方法
  - FileInputStream(File file);通過開啟與實際檔案的連結來建立一個FileInputStream，該檔案由檔案系統中的File物件file命名。
  - FileInputStream(String name)：通過開啟與實際檔案的連結來建立一個FileInputStream，該檔案由檔案系統中的路徑名name命名。
    
    當你建立一個流物件時，必須傳入一個檔案路徑。該路徑下，如果沒有改檔案，會丟擲FilenotFoundException。
    
    程式碼示例：
```
public class Demo02FileInputStream {

    public static void main(String[] args) throws IOException {
        //1.建立物件
        FileInputStream fos = new FileInputStream("c.txt");
        //2.呼叫read(byte b)輸入流中讀取多個位元組，並且將其儲存到緩衝區陣列b當中。
        //2.1構建一個byte陣列
        int len =0;
        byte[] bytes = new byte[1024];
//        int i = fos.read(bytes);
//        System.out.println(i);//每次讀到的有效數字個數
//        System.out.println(Arrays.toString(bytes));
        while ((len = fos.read(bytes))!=-1){
            //byte[] 轉換成string
            //String(byte[] bytes,int offset,int length)可以把位元組陣列的一部分轉換成字串
            //System.out.println(Arrays.toString(bytes));
            System.out.println(new String(bytes,0,len));
        }


    }
}
```
    可以使用位元組陣列來讀取資料：read(byte[] b):從輸入流中讀取多個位元組，並且將其儲存到緩衝區陣列b當中讀取到檔案的末尾時，返回一個-1
    
    程式碼演示：
```
  //1.建立物件
        FileInputStream fos = new FileInputStream("c.txt");
        int len =0;
        byte[] bytes = new byte[1024];
 while ((len = fos.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
 }
    }
}
```
    備註：使用陣列讀取，每次可以讀取多個位元組，減少了系統間的IO操作次數，從而提高了讀取的效率，建議使用。
    
    練習：通過位元組流實現圖片複製
    
    實現從桌面副本.jpg複製到D盤D:\奔奔目錄下。
    
    原理：從已知的檔案中讀取位元組，再把讀取到的位元組寫入到另一個檔案中。
    
    例項程式碼：
```
 public static void main(String[] args) throws IOException {
        FileInputStream fos = new FileInputStream("C:\\Users\\86175\\Desktop\\副本.jpg");
        FileOutputStream fi = new FileOutputStream("D:\\奔奔\\副本.jpg");
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len=fos.read(bytes))!=-1){
            fi.write(bytes);
        }
        fos.close();
        fi.close();
    }
```
    備註：流的關閉順序：先開後關，後開先關
    
    字元流
    
    當使用位元組流讀取文字檔案的時候，可能會引發一點小問題。如果你遇到了中文字元時，可能不會顯示完整的字元。那就是因為一箇中文字元可能佔用多個位元組儲存。所以Java提供了一些字元流類，以字元為單位讀寫資料，專門用於處理文字文件檔案。
    
    字元輸入流Reader
    
    “java.io.Reader”抽象類是表示用於讀取字元流的所有類的超類，可以讀取字元資訊到記憶體當中，它定義了字元輸入流的基本共性的API方法
    
    public void close();關閉此輸入流並且釋放與此流相關的其他系統資源
    
    public int read();從輸入流中讀取一個字元
    
    public int read(char[] chuf);從輸入流中一次讀取多個字元，並將它們儲存到字元陣列chuf當中
    
    FileReader類
    
    “java.io.FileReader”類主要是用於讀取字元檔案的便捷類。構造方法使用時預設的編碼字符集和預設的位元組緩衝區。
    
    備註：
    
    1.字元編碼位元組與字元的對應規則。Windows系統中的中文編碼預設是GBK編碼表，idea中採用UTF-8
    
    2.位元組緩衝區：一個位元組陣列，用來臨時儲存位元組資料。
    
    構造方法
    - FileReader(File file)；建立一個新的FileReader物件，指定需要讀取的file物件。
    - FileReader(String filename);建立一個新的FileReader物件，指定需要讀取的檔名稱。
      
      當你建立一個流物件時，必須傳入一個檔案路徑。類似於FileInputStream。
      
      程式碼示例
```
 public static void main(String[] args) throws IOException {
             //1.建立物件，構造方法中繫結需要讀取的檔案資料與
        FileReader fis = new FileReader("c.txt");
        //2.使用該物件中的方法read()來讀取檔案資料
        //int read()讀取單個字元並返回
        int len = fis.read();
        System.out.println((char) len);//72 H 張
           //3.釋放資源，關閉此輸入流。
        fis.close();

    }
```
      使用字元陣列讀取資料：read(char[] chuf);每次讀取chuf的長度個字元到陣列當中，返回讀取到有效字元的個數
      
      當它讀取到末尾時，返回-1.
      
      程式碼示例：
```
 public static void main(String[] args) throws IOException {
             //1.建立物件，構造方法中繫結需要讀取的檔案資料與
        FileReader fis = new FileReader("c.txt");
        //2.使用該物件中的方法read()來讀取檔案資料
        //int read()讀取單個字元並返回
        int len = fis.read();
        System.out.println((char) len);//72 H 張
           //3.釋放資源，關閉此輸入流。
        fis.close();

    }
```
      字元輸出流Writer
      
      “java.io.writer”抽象類是表示用於輸出字元流的所有類的超類。將指定的字元資訊寫入到目的地中。它定義了字元輸出流的基本共性的API方法：
      - void write(int c);寫入單個字元
      - void write(char[] chuf);寫入字元陣列
      - abstract void write(char[] chuf,int off,int len);寫入char陣列的一部分，從char陣列的起始索引值off開始，len個寫入字元個數。
      - void write(String str);寫入字串。
      - void write(String str,int off,int len);寫入字串的一部分，從字串的起始索引off開始，寫入len個字元個數。
      - void flush();重新整理該流的緩衝。
      - void close();關閉此流，但是需要先重新整理它。
        
        FileWriter類
        
        “java.io.Filewriter”類是用於寫入字元到檔案中。構造方法使用系統預設的字元編碼和預設的位元組緩衝區。
        
        構造方法
        
        FileWriter(File file);建立一個新的FileWriter，指定寫入file物件。
        
        FileWriter(String filename);建立一個新的FileWriter，指定需要寫入的檔案的名稱。
        
        當你建立一個流物件時，必須傳入一個檔案路徑，類似於FileOutputStream
        
        程式碼示例：
        
        public static void main(String[] args) throws IOException { //1.建立一個FileWriter物件，構造方法中繫結需要寫入資料的目的地 FileWriter fw = new FileWriter("d.txt"); //2.使用fileWriter物件中的方法write，把資料寫入到記憶體緩衝區中(字元轉換為位元組的過程) //void write(int c)寫入單個字元 fw.write(122);//z //3.使用FileWriter物件中的方法flush，把記憶體緩衝區中的資料重新整理到檔案中。 //fw.flush(); //4.釋放資源(會先把記憶體緩衝區中的資料重新整理到檔案中) fw.close(); }
        
        關閉和重新整理
        
        因為內建緩衝區的原因，如果不關閉輸出流，無法寫入字元到檔案中。但是關閉流物件，是無法繼續寫入資料到檔案中。如果即想寫入到資料到檔案中，又想繼續使用流物件，那麼就需要flush方法
        
        flush：重新整理緩衝區，流物件可以繼續使用
        
        close：先重新整理緩衝區，然後會通知系統釋放資源，關閉流物件，流物件不可以再使用
        
        程式碼演示：
        
        public static void main(String[] args) throws IOException { //1.建立物件 FileWriter fw = new FileWriter("e.txt"); //2.呼叫writer方法 fw.write(97);//a //3.重新整理 fw.flush(); //重新整理之後流可以繼續使用 fw.write(98); fw.close(); //close方法之後流已經關閉了，已經從記憶體當中消失了，流不能再使用了，如果使用 //Exception in thread "main" java.io.IOException: Stream closed fw.write(99); }
        
        寫入字元陣列：write(char[] cbuf) 和write(char[] chuf,int off,int len)，每次可以寫入一個字元陣列中的資料，用法類似於FileOutoutStream
        
        程式碼示例：
        
        public static void main(String[] args) throws IOException { //1.new FileWriter fw = new FileWriter("f.txt"); //2.write char[] chars = new char[]{'a','b','c','d','e','f'}; fw.write(chars);//abcdef // abstract void write(char[] chuf,int off,int len);寫入字元陣列的一部分，從off起始索引開始，寫入len個字元個數 fw.write(chars,3,3);//def //void write(String str);寫入一個字串 fw.write("你好,Java"); //void write(String str,int off,int len);寫入字串的一部分，從off開始，寫入len個字元個數 fw.write("你好,Java",3,4);//Java //3.重新整理 fw.flush(); //4.關閉 fw.close(); }
        
        程式碼示例：
        
        續寫和換行：操作類似於FileOutputStream
        
        public static void main(String[] args) throws IOException { //1.建立物件 FileWriter fw = new FileWriter("g.txt",true); //2.whrite //fw.write(new char[]{'李','王','趙','孫'}); char[] chars = new char[50]; for (int i=0;i<50;i++){ chars[i]=(char)(20000+i); fw.write(chars[i]+"\r\n"); } //3.重新整理 fw.flush(); //4.關閉 fw.close(); }
        
        備註：字元流，只能操作文字檔案，不能操作圖片，視訊非文字檔案。
        
        所以當我們單純的就是操作文字檔案，就是要字元流，其他清空一律使用位元組流。
        
        IO異常的處理
        
        JDK1.7之前的處理
        
        public static void main(String[] args) { //提高變數的作用域 FileWriter fw =null; //1.new try { fw = new FileWriter("g.txt", true); //2.write fw.write(97); //3.重新整理 fw.flush(); } catch (IOException e) { e.printStackTrace(); }finally { try { fw.close(); } catch (IOException e) { e.printStackTrace(); } } }
        
        JDK7新特性
        
        可以使用try-with-resource語句，該語句確保了每個資源在語句結束時關閉，所謂的資源(resource)是指在程式完成後，必須要關閉的物件。
        
        格式：
        
        try(建立流物件語句，如果多個，請使用";"隔開){ //可能產生異常的程式碼 }catch(異常型別異常變數名){ //異常處理邏輯 }
        
        例項程式碼：
        
        public static void main(String[] args) { try(FileWriter fw = new FileWriter("a.txt",true); FileReader fr = new FileReader("a.txt");){ //2.write int len = 0; while((len = fr.read())!=-1){ fw.write(len); } }catch (IOException e){ e.printStackTrace(); } }
        
        屬性集Properties