Java基礎知識筆記九（詳細）

IO流概述和分類

1,IO流用來處理設備之間的數據傳輸
(1)上傳文件(上傳頭像)和下載文件(迅雷)
(2)文件複製(U盤拷貝)
2,IO流分類
(1)輸出流
FileWriter(全稱字符輸出流)
(2)輸入流
FileReader(全稱字符輸入流)
3,注意:
流的種類有很多種，目前先學習一些基本的和高效的輸入輸出流。
Java中的IO模型設計非常的優秀，它使用了設計模式中的裝飾者模式。

FileWriter寫數據

1,構造方法
傳遞一個文件的名稱，根據文件名稱創建輸出流對象
public FileWriter(String fileName){} ;

//創建輸出流對象
FileWriter fw = new FileWriter("d://a.txt");

傳遞一個文件的名稱以及是否追加，根據文件名稱創建輸出流對象
public FileWriter(String filename,boolean append){};
2,成員方法
寫一個字符串到指定的文件中
public void write(String str){};

//使用輸出流中的方法完成數據的輸出
fw.write("你好呀！");

將緩衝區的數據刷新到文件中
public void flush(){}:

//把數據寫到了緩衝區
fw.flush();

將程序與硬盤之間打開的資源進行釋放
public void close(){}:

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

一定注意需要釋放資源
3,注意事項
(1)flush() 刷新緩衝區，只要沒有close，那麼就可以一直寫出數據。
(2)close() 會先檢查緩衝區是否需要刷新，然後在釋放資源，只要close了，那麼是不可以在寫出數據了。
(3)相對路徑:相當於你當前項目而言
(4)絕對路徑:明確指定了盤符對應的具體位置

FileWriter寫數據的方法

寫一個字符串到指定的文件中
public void write(String str){};
寫一個字符串的一部分到指定的文件中
public void write(String str,int index,int len){};
寫一個字符到指定的文件中
public void write(int ch){}:;
寫一個字符數組到指定的文件中
public void write(char[] chs){};
寫一個字符數組的一部分到指定的文件中
public void write(char[] chs,int index,int len){};

public static void main(String[] args) throws IOException {
    //創建輸出流
    FileWriter fw = new FileWriter("a.txt");
    //write(String str)
    fw.write("hello china");

    //write(String str,int index,int len)
    String str = "hello china";
    fw.write(str,2,3);

    //write(int ch)
    fw.write(97);

    //write(char[] chs)
    char[] chs = {'a','b','c','d','e'};
    fw.write(chs);

    //write(char[] chs,int index,int len)
    fw.write(chs,1,3);

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

FileWriter寫數據常見問題

1,如何實現數據的換行?
(1)假如我現在要寫一個main函數到文件，期望有換行效果。

int main()
{return 0;}

2,如何實現數據的追加寫入?
(1) 使用輸出流對象去寫數據，每次執行程序，都會幫我們刪除之前的文件，然後創建新文件，如果期望把之前文件裏面的數據保留，繼續添加新的數據進去，不覆蓋，這個時候就可以使用FileWriter(String filename，boolean append)的這個構造完成數據的追加。

public static void main(String[] args) throws IOException {
    //創建輸出流對象
    FileWriter fw = new FileWriter("b.txt",true);
    //寫數據
    fw.write("int main()\r\n");
    fw.write("{return 0;}\r\n");
    //釋放資源
    fw.close();
}

FileReader讀數據

1,構造方法
根據文件名稱創建輸入流對象
public FileReader(String fileName){}:

//創建輸入流對象
FileReader fr = new FileReader("b.txt");

2,成員方法
一次讀取一個字符
public int read(){}

//讀取數據public int read() 一次讀取一個字符
int read1 = fr.read();
System.out.println((char)read1);
public int read(char[] cbuf) {}:一次讀取一個字符數組
char[] chs = new char[1024];//建議寫1024或者倍數
int len = fr.read(chs);//返回的len是讀取到的字符個數
public void close(){}:將程序與硬盤之間打開的資源進行釋放
//釋放資源
fr.close();

IO流案例

1,複製文本文件
(1)一次讀寫一個字符

//創建輸入流對象
FileReader fr = new FileReader("1.txt");
int ch;
while((ch=fr.read()) != -1){
    System.out.print((char)ch);
}
//釋放資源
fr.close();

(2) 一次讀寫一個字符數組

//創建輸入流對象
FileReader fr = new FileReader("1.txt");
//創建輸出流對象
FileWriter fw = new FileWriter("copy.txt");
//public int read(char[] cbuf) {}:一次讀取一個字符數組
char[] chs = new char[1024];//建議寫1024或者倍數
 while((fr.read(chs) != -1)){
            fw.write(chs);
        }
//釋放資源
fw.close();
fr.close();

字符緩衝流

1,BufferedWriter基本用法
根據基本的輸出流創建緩衝輸出流對象
public BufferedWriter(Writer out) {}

//創建緩衝輸出流
BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
bw.write("hello China");
//bw.flush();
bw.close();

2,BufferedReader基本用法
根據基本的輸入流創建緩衝輸入流對象
public BufferedReader(Reader in) {}

//創建緩衝輸入流
BufferedReader br = new BufferedReader(new FileReader("c.txt"));
//一次讀取一個字符
int ch;
while((ch = br.read()) != -1){
    System.out.print((char)ch);
}
br.close();

3,字符緩衝流複製文本文件

public static void main(String[] args) throws IOException {
    //method1();
    method2();//調用方法
}

(1)使用緩衝流一次讀取一個字符的方式複製文件

public static void method1() throws IOException {
    //創建緩衝輸入流
    BufferedReader br = new BufferedReader(new FileReader("1.txt"));
    //創建緩衝輸出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
    //讀取數據到內存  一次讀取一個字符
    int ch;
    while((ch = br.read()) != -1){
        //寫出數據到硬盤
        bw.write(ch);
    }
    //釋放資源
    bw.close();
    br.close();
}

(2)使用緩衝流一次讀取一個字符數組的方式複製文件

public static void method2() throws IOException {
    //創建緩衝輸入流
    BufferedReader br = new BufferedReader(new FileReader("1.txt"));
    //創建緩衝輸出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
    //讀取數據到內存  一次讀取一個字符數組
    char[] chars = new char[1024];
    int len;
    while((len = br.read(chars)) != -1){
        //寫出數據到硬盤，建議讀取到多少個，就寫多少個
        bw.write(chars,0,len);
    }
    //釋放資源
    bw.close();
    br.close();
}

4.特殊功能

//BufferedWriter
public void newLine(){}:一次讀取一行數據
//創建緩衝輸出流
BufferedWriter bw = new BufferedWriter(new FileWriter("e.txt"));
//寫數據
bw.write("int main()");
bw.newLine();
bw.write("{return 0;}");
//釋放資源
bw.close();
//BufferedReader
//public String readLine(){}:寫一個換行
//創建緩衝輸入流
BufferedReader br = new BufferedReader(new FileReader("e.txt"));
//讀數據
String str;
while((str = br.readLine()) != null){
    System.out.println(str);
}
//釋放資源
br.close();

5.字符緩衝流特殊功能複製文本文件

public static void main(String[] args) throws IOException {
    //創建緩衝輸入流
    BufferedReader br = new BufferedReader(new FileReader("1.txt"));
    //創建緩衝輸出流
    BufferedWriter bw = new BufferedWriter(new FileWriter("copy2.txt"));
    //使用緩衝流的特殊功能
    String str;
    while((str = br.readLine()) != null){
        bw.write(str);
        bw.newLine();
    }
    //釋放資源
    bw.close();
    br.close();
}

IO流練習

1,複製文本文件(5種方式)

public static void main(String[] args) throws IOException {
    String  srcFileName = "1.txt";
    String  descFileName = "copy3.txt";
    method01(srcFileName,descFileName);
    method02(srcFileName,descFileName);
    method03(srcFileName,descFileName);
    method04(srcFileName,descFileName);
    method05(srcFileName,descFileName);
}

(1)使用基本流一次讀取一個字符

public static void method01(String srcFileName, String descFileName) throws IOException {
    //創建基本的輸入流
    FileWriter fw = new FileWriter(descFileName);
    //創建基本的輸出流
    FileReader fr = new FileReader(srcFileName);
    //一次讀取一個字符
    int ch;
    while((ch = fr.read()) != -1){
        System.out.println(ch);
        fw.write(ch);
    }
    //釋放資源
    fr.close();
    fw.close();
}

(2)使用基本流一次讀取一個字符數組

public static void method02(String srcFileName, String descFileName) throws IOException {
    //創建基本的輸入流
    FileWriter fw = new FileWriter(descFileName);
    //創建基本的輸出流
    FileReader fr = new FileReader(srcFileName);
    //一次讀取一個字符數組
    char[] chs = new char[1024];
    int len;
    while((len = fr.read(chs)) != -1){
        fw.write(chs,0,len);
    }
    //釋放資源
    fr.close();
    fw.close();
}

(3)使用緩衝流一次讀取一個字符

public static void method03(String srcFileName, String descFileName) throws IOException {
    //創建基本的輸出流
    FileWriter fw = new FileWriter(descFileName);
    //創建高效的輸出流
    BufferedWriter bw = new BufferedWriter(fw);
    //創建基本的輸入流
    FileReader fr = new FileReader(srcFileName);
    //創建高效的輸入流
    BufferedReader br = new BufferedReader(fr);
    //一次讀取一個字符
    int ch;
    while((ch = br.read()) != -1){
        System.out.println(ch);
        bw.write(ch);
    }
    //釋放資源
    br.close();
    fr.close();
    bw.close();
    fw.close();
}

(4)使用緩衝流一次讀取一個字符數組

public static void method04(String srcFileName, String descFileName) throws IOException {
    //創建基本的輸出流
    FileWriter fw = new FileWriter(descFileName);
    //創建高效的輸出流
    BufferedWriter bw = new BufferedWriter(fw);
    //創建基本的輸入流
    FileReader fr = new FileReader(srcFileName);
    //創建高效的輸入流
    BufferedReader br = new BufferedReader(fr);
    //一次讀取一個字符數組
    char[] chs = new char[1024];
    int len;
    while((len = br.read(chs)) != -1){
        bw.write(chs,0,len);
    }
    //釋放資源
    br.close();
    fr.close();
    bw.close();
    fw.close();
}

(5)使用緩衝流的特殊功能

public static void method05(String srcFileName, String descFileName) throws IOException {
    //創建基本的輸出流
    FileWriter fw = new FileWriter(descFileName);
    //創建高效的輸出流
    BufferedWriter bw = new BufferedWriter(fw);
    //創建基本的輸入流
    FileReader fr = new FileReader(srcFileName);
    //創建高效的輸入流
    BufferedReader br = new BufferedReader(fr);
    //使用緩衝流的特殊功能
    String str;
    while((str = br.readLine()) != null){
        bw.write(str);
        bw.newLine();
    }
    //釋放資源
    br.close();
    fr.close();
    bw.close();
    fw.close();
}