IO流

• IO流概述及FileWriter類的使用
• FileReader類使用
• 緩沖流介紹和使用
• IO流相關案例

NO.one IO流概述及FileWriter類使用

1.1 IO流概述及分類

IO流用來處理設備之間的數據傳輸

Java對數據的操作是通過流的方式

Java用於操作流的類都在IO包中

流按流向分為兩種：輸入流，輸出流

1.2 FileWriter類使用

A:打開幫助文檔

B:點擊顯示，找到索引，看到輸入框

C:你要學習什麽內容，你就在框框裏面輸入什麽內容

舉例：Random

D:看包

java.lang包下的類在使用的時候是不需要導包的

E:看類的描述

Random類是用於生成隨機數的類

F:看構造方法

Random():無參構造方法

Random r = new Random();

G:看成員方法

public int nextInt(int n):產生的是一個[0,n)範圍內的隨機數

調用方法：

看返回值類型：人家返回什麽類型，你就用什麽類型接收

看方法名：名字不要寫錯了

看形式參數：人家要幾個參數，你就給幾個，人家要什麽數據類型的，

你就給什麽數據類型的

int number = r.nextInt(100);

1.2.1 FileWriter向文件中寫數據

A:FileWriter向文件中寫數據操作步驟:

a:使用FileWriter流關聯文件

b:利用FileWriter的寫方法寫數據

c:利用FileWriter的刷新方法將數據從內存刷到硬盤上

d:利用FileWriter的關流方法將釋放占用的系統底層資源

B:FileWriter方法:

構造方法

FileWriter(String fileName) 傳入一個文件的路徑

成員方法

void write(String str) 向文件中寫str

void flush() 將內存中的數據刷新到文件中

void close() 關流釋放系統底層資源

1.2.1.1 案例代碼一：

package com.gao_01;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：往文件中寫數據
 *         寫數據--輸出流--FileWriter
 * 
 * FileWriter:
 *         FileWriter(String fileName):傳遞一個文件名稱
 * 
 * 輸出流寫數據的步驟：
 *         A:創建輸出流對象
 *         B:調用輸出流對象的寫數據的方法
 *         C:釋放資源
 */
public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        //創建輸出流對象
        FileWriter fw = new FileWriter("d:\\a.txt");
        /*
         * 創建輸出流對象做了哪些事情:
         *         A:調用系統資源創建了一個文件
         *         B:創建輸出流對象
         *         C:把輸出流對象指向文件
         */
        
        //調用輸出流對象的寫數據的方法
        //寫一個字符串數據
        fw.write("IO流你好");
        //數據沒有直接寫到文件，其實是寫到了內存緩沖區
        fw.flush();
        
        //釋放資源
        //通知系統釋放和該文件相關的資源
        fw.close();
        
        //while(true) {}
    }
}

1.2.2 FileWriter 註意事項

1.2.2.1 案例代碼二：

package com.gao_01;

import java.io.FileWriter;
import java.io.IOException;

/*
 * 輸出流寫數據的步驟：
 *         A:創建輸出流對象
 *         B:調用輸出流對象的寫數據方法，並刷新緩沖區
 *         C:釋放資源
 * 
 * 相對路徑：相對當前項目而言的，在項目的根目錄下(a.txt)
 * 絕對路徑：以盤符開始的路徑(d:\\a.txt)
 * 
 * close()和flush()方法的區別：
 *         flush():刷新緩沖區。流對象還可以繼續使用。
 *         close():先刷新緩沖區，然後通知系統釋放資源。流對象不可以再被使用了。
 */
public class FileWriterDemo2 {
    public static void main(String[] args) throws IOException {
        //創建輸出流對象
        //FileWriter fw = new FileWriter("d:\\a.txt");
        FileWriter fw = new FileWriter("a.txt");
        
        //調用輸出流對象的寫數據方法，並刷新緩沖區
        fw.write("helloworld");
        fw.flush();
        fw.write("java");
        fw.flush();
        
        //釋放資源
        fw.close();
        
        //Stream closed
        //fw.write("javaee");
        //fw.flush();
    }
}

1.2.3 FileWriter 其他寫方法

void write(String str):寫一個字符串數據

void write(String str,int index,int len):寫一個字符串中的一部分數據

void write(int ch):寫一個字符數據,這裏寫int類型的好處是既可以寫char類型的數據，

也可以寫char對應的int類型的值。‘a‘,97

void write(char[] chs):寫一個字符數組數據

void write(char[] chs,int index,int len):寫一個字符數組的一部分數據

1.2.3.1 案例代碼三：

package com.gao_01;
import java.io.FileWriter;
import java.io.IOException;

/*
 * void write(String str):寫一個字符串數據
 * void write(String str,int index,int len):寫一個字符串中的一部分數據
 * void write(int ch):寫一個字符數據,這裏寫int類型的好處是既可以寫char類型的數據，也可以寫char對應的int類型的值。‘a‘,97
 * void write(char[] chs):寫一個字符數組數據
 * void write(char[] chs,int index,int len):寫一個字符數組的一部分數據
 */
public class FileWriterDemo3 {
    public static void main(String[] args) throws IOException {
        //創建輸出流對象
        FileWriter fw = new FileWriter("b.txt");
        
        //void write(String str):寫一個字符串數據
        //fw.write("abcde");
        
        //void write(String str,int index,int len):寫一個字符串中的一部分數據
        //fw.write("abcde",0,5);
        //fw.write("abcde",1,3);
        
        //void write(int ch):寫一個字符數據,這裏寫int類型的好處是既可以寫char類型的數據，也可以寫char對應的int類型的值。‘a‘,97
        //fw.write(‘a‘);
        //fw.write(97);
        
        //void write(char[] chs):寫一個字符數組數據
        char[] chs = {‘a‘,‘b‘,‘c‘,‘d‘,‘e‘};
        //fw.write(chs);
        
        //void write(char[] chs,int index,int len):寫一個字符數組的一部分數據
        //fw.write(chs,0,5);
        fw.write(chs,2,3);
        
        //釋放資源
        fw.close();
    }
}

1.2.4 FileWriter 寫入換行以及向文本末尾追加

1.2.4.1 案例代碼四：

package com.gao_01;

import java.io.FileWriter;
import java.io.IOException;

/*
 * 如何實現數據的換行?
 *         \n可以實現換行，但是windows系統自帶的記事本打開並沒有換行，這是為什麽呢?因為windows識別的換行不是\n，而是\r\n
 *         windows:\r\n
 *         linux:\n
 *         mac:\r
 * 如何實現數據的追加寫入?
 *         FileWriter(String fileName, boolean append)
 */
public class FileWriterDemo4 {
    public static void main(String[] args) throws IOException {
        //創建輸出流對象
        //FileWriter fw = new FileWriter("c.txt");
        FileWriter fw = new FileWriter("c.txt",true); //表示追加寫入，默認是false
        
        for(int x=0; x<10; x++) {
            fw.write("hello"+x);
            fw.write("\r\n");
        }
        
        //釋放資源
        fw.close();
    }
}

NO.two FileReader類使用

2.1 FileReader 讀數據一次讀取一個字符

2.1.1 案例代碼五：

package com.gao_02;
import java.io.FileReader;
import java.io.IOException;

/*
 * 需求：從文件中讀數據並顯示到控制臺
 *         讀數據--輸入流--FileReader
 * 
 * FileReader:
 *         FileReader(String fileName):傳遞文件名稱
 * 
 * 輸入流讀文件的步驟：
 *         A:創建輸入流對象
 *         B:調用輸入流對象的讀數據方法
 *         C:釋放資源
 * 
 * java.io.FileNotFoundException: fr.txt (系統找不到指定的文件。)
 */
public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //創建輸入流對象
//        FileReader fr = new FileReader("fr.txt");
        FileReader fr = new FileReader("FileWriterDemo.java");
        
        //調用輸入流對象的讀數據方法
        //int read():一次讀取一個字符
        
        /*
        //第一次讀數據
        int ch = fr.read();
        System.out.println(ch);
        System.out.println((char)ch);
        
        //第二次讀數據
        ch = fr.read();
        System.out.println(ch);
        System.out.println((char)ch);
        
        //第三次讀數據
        ch = fr.read();
        System.out.println(ch);
        System.out.println((char)ch);
        
        //這是時候，我們發現代碼的重復度很高，想用循環改進，但是不知道循環的結束條件是什麽
        ch = fr.read();
        System.out.println(ch);
        
        ch = fr.read();
        System.out.println(ch);
        //通過測試，我們知道，如果讀取數據的返回值是-1的時候，就說明沒有數據了，這也是我們循環的結束條件
        */
        
        int ch;
        //1:fr.read()
        //2:ch=fr.read()
        //3:ch != -1
        while((ch=fr.read())!=-1) {
            //System.out.println(ch);
            //System.out.println((char)ch);
            System.out.print((char)ch);
        }
        
        //釋放資源
        fr.close();
    }
}

2.2 利用FileReader 和 FileWriter完成文件復制

2.2.1 讀一次寫一次

2.2.1.1 案例代碼六：

package com.gao_03;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：
 *         把項目路徑下的FileWriterDemo.java中的內容復制到項目路徑下的Copy.java中
 * 
 * 文件復制也是有規律可循的，也就是說有套路。
 * 
 * 數據源：
 *         FileWriterDemo.java -- 讀數據 -- FileReader
 * 目的地：
 *         Copy.java -- 寫數據 -- FileWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //創建輸入流對象
        FileReader fr = new FileReader("FileWriterDemo.java");
        //創建輸出流對象
        FileWriter fw = new FileWriter("Copy.java");
        
        //讀寫數據
        int ch;
        while((ch=fr.read())!=-1) {
            fw.write(ch);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

2.2.2 利用字符數組拷貝文件

2.2.2.1 案例代碼七：

package com.gao_03;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：
 *         把項目路徑下的FileWriterDemo.java中的內容復制到項目路徑下的Copy.java中
 * 
 * 數據源：
 *         FileWriterDemo.java -- 讀數據 -- FileReader
 * 目的地：
 *         Copy.java -- 寫數據 -- FileWriter
 */
public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        //創建輸入流對象
        FileReader fr  = new FileReader("FileWriterDemo.java");
        //創建輸出流對象
        FileWriter fw = new FileWriter("Copy.java");
        
        //讀寫數據
        char[] chs = new char[1024];
        int len;
        while((len=fr.read(chs))!=-1) {
            fw.write(chs, 0, len);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

2.2.3 拷貝文件的兩種方式圖解

NO.three 緩沖流介紹和使用

3.1 緩沖流的基本使用

3.1.1 案例代碼八：

package com.gao_04;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * BufferedWriter:將文本寫入字符輸出流，緩沖各個字符，從而提供單個字符、數組和字符串的高效寫入。 
 * BufferedReader:從字符輸入流中讀取文本，緩沖各個字符，從而實現字符、數組和行的高效讀取。
 */
public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //創建輸出緩沖流對象
        /*
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
        bw.write("hello");
        //bw.flush();
        bw.close();
        */
        
        //創建輸入緩沖流對象
        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
        
        /*
        //一次讀寫一個字符
        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();
        
    }
}

3.2 緩沖流復制文本文件的兩種方式

利用緩沖流把項目路徑下的FileWriterDemo.java中的內容復制到項目路徑下的Copy.java中

第一種方式:使用緩沖流不使用字符數組

第二種方式:使用緩沖流使用字符數組

3.2.1 案例代碼九：

package com.gao_04;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：
 *         把項目路徑下的FileWriterDemo.java中的內容復制到項目路徑下的Copy.java中
 * 
 * 數據源：
 *         FileWriterDemo.java -- 讀數據 -- FileReader -- 高效的讀數據 -- BufferedReader
 * 目的地：
 *         Copy.java -- 寫數據 -- FileWriter -- 高效的寫數據 -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //創建輸入緩沖流對象
        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
        //創建輸出緩沖流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        
        //讀寫數據
        /*
        //一次讀寫一個字符
        int ch;
        while((ch=br.read())!=-1) {
            bw.write(ch);
        }
        */
        
        
//一次讀寫一個字符數組
        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs))!=-1) {
            bw.write(chs,0,len);
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
}

3.3 緩沖流的特有方法使用

BufferedWriter

void newLine():寫一個換行符，這個換行符由系統決定,不同的操作系統newLine()方法使用的換行符不同

windows: \r\n

linux: \n

mac: \r

BufferedReader

String readLine():一次讀取一行數據，但是不讀取換行符

3.3.1 案例代碼十：

package com.gao_05;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * 緩沖流的特殊功能：
 * BufferedWriter
 *         void newLine():寫一個換行符，這個換行符由系統決定
 * BufferedReader
 *         String readLine():一次讀取一行數據，但是不讀取換行符
 */
public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
        for(int x=0; x<10; x++) {
            bw.write("hello"+x);
            //bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        bw.close();
        */
        
        BufferedReader br = new BufferedReader(new FileReader("br.txt"));
        
        /*
        String line = br.readLine();
        System.out.println(line);
        
        line = br.readLine();
        System.out.println(line);
        
        line = br.readLine();
        System.out.println(line);
        
        line = br.readLine();
        System.out.println(line);
        */
        
        String line;
        //1:br.readLine()
        //2:line=br.readLine()
        //3:line != null
        while((line=br.readLine())!=null) {
            System.out.println(line);
        }
        
        br.close();
    }
}

3.4 緩沖流的特有方法復制文件

3.4 案例代碼十一：

package com.gao_05;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
 * 需求：
 *         把項目路徑下的FileWriterDemo.java中的內容復制到項目路徑下的Copy.java中
 * 
 * 數據源：
 *         FileWriterDemo.java -- 讀數據 -- FileReader -- 高效的讀數據 -- BufferedReader
 * 目的地：
 *         Copy.java -- 寫數據 -- FileWriter -- 高效的寫數據 -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //創建輸入緩沖流對象
        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
        //創建輸出緩沖流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        
        //讀寫數據
        String line;
        while((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //釋放資源
        bw.close();
        br.close();
    }
}

NO.four IO流相關案例

4.1 復制文本文件的5中方式

A:利用基本流一次讀寫一個字符

B:利用基本流一次讀寫一個字符數組

C:利用緩沖流一次讀寫一個字符

D:利用緩沖流一次讀寫一個字符數組

E:利用緩沖流的特有方法一次讀寫一個字符串

4.1.1 案例代碼十二：

package com.gao_06;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 復制文本文件(5種方式)
 * 
 * 數據源：
 *         FileWriterDemo.java
 * 目的地：
 *         Copy.java
 */
public class CopyFileTest {
    public static void main(String[] args) throws IOException {
        /*
        method1("FileWriterDemo.java","Copy.java");
        method2("FileWriterDemo.java","Copy.java");
        method3("FileWriterDemo.java","Copy.java");
        method4("FileWriterDemo.java","Copy.java");
        method5("FileWriterDemo.java","Copy.java");
        */
        
        String srcFileName = "FileWriterDemo.java";
        String destFileName = "Copy.java";
        
//        method1(srcFileName,destFileName);
//        method2(srcFileName,destFileName);
        method3(srcFileName,destFileName);
//        method4(srcFileName,destFileName);
//        method5(srcFileName,destFileName);
    }
    
    //緩沖流一次讀寫一個字符串
    public static void method5(String srcFileName,String destFileName) throws IOException {
        //創建輸入緩沖流對象
        BufferedReader br = new BufferedReader(new FileReader(srcFileName));
        //創建輸出緩沖流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
        
        //一次讀寫一個字符串
        String line;
        while((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
    
    //緩沖流一次讀寫一個字符數組
    public static void method4(String srcFileName,String destFileName) throws IOException {
        //創建輸入緩沖流對象
        BufferedReader br = new BufferedReader(new FileReader(srcFileName));
        //創建輸出緩沖流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
        
        //一次讀寫一個字符數組
        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs))!=-1) {
            bw.write(chs,0,len);
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
    
    //緩沖流一次讀寫一個字符
    public static void method3(String srcFileName,String destFileName) throws IOException {
        //創建輸入緩沖流對象
        BufferedReader br = new BufferedReader(new FileReader(srcFileName));
        //創建輸出緩沖流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
        
        //一次讀寫一個字符
        int ch;
        while((ch=br.read())!=-1) {
            bw.write(ch);
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
    
    //基本流一次讀寫一個字符數組
    public static void method2(String srcFileName,String destFileName) throws IOException {
        //創建輸入流對象
        FileReader fr = new FileReader(srcFileName);
        //創建輸出流對象
        FileWriter fw = new FileWriter(destFileName);
        
        //一次讀寫一個字符數組
        char[] chs = new char[1024];
        int len;
        while((len=fr.read(chs))!=-1) {
            fw.write(chs,0,len);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
    
    //基本流一次讀寫一個字符
    public static void method1(String srcFileName,String destFileName) throws IOException {
        //創建輸入流對象
        FileReader fr = new FileReader(srcFileName);
        //創建輸出流對象
        FileWriter fw = new FileWriter(destFileName);
        
        //一次讀寫一個字符
        int ch;
        while((ch=fr.read())!=-1) {
            fw.write(ch);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

4.2 把集合中的數據寫到文本文件

把ArrayList集合中的字符串數據存儲到文本文件項目根目下的array.txt中

每一個字符串元素作為文件中的一行數據

4.2.1 案例代碼十三：

package com.gao_06;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/*
 * 把ArrayList集合中的字符串數據存儲到文本文件
 * 每一個字符串元素作為文件中的一行數據
 * 
 * 分析：
 *         A:創建集合對象
 *         B:往集合中添加字符串元素
 *         C:創建輸出緩沖流對象
 *         D:遍歷集合，得到每一個字符串元素，然後把該字符串元素作為數據寫到文本文件
 *         E:釋放資源
 */
public class ArrayListToFileTest {
    public static void main(String[] args) throws IOException {
        //創建集合對象
        ArrayList<String> array = new ArrayList<String>();
        
        //往集合中添加字符串元素
        array.add("hello");
        array.add("world");
        array.add("java");
        
        //創建輸出緩沖流對象
        BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));
        
        //遍歷集合，得到每一個字符串元素，然後把該字符串元素作為數據寫到文本文件
        for(int x=0; x<array.size(); x++) {
            String s = array.get(x);
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        
        //釋放資源
        bw.close();
    }
}

4.3 把文本文件中的數據讀取到集合

從項目根目錄下的array.txt文本文件中讀取數據到ArrayList集合中，並遍歷集合,每一行數據作為一個字符串元素

4.3.1 案例代碼十四：

package com.gao_06;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

/*
 * 從文本文件中讀取數據到ArrayList集合中，並遍歷集合
 * 每一行數據作為一個字符串元素
 * 
 * 分析：
 *         A:創建輸入緩沖流對象
 *         B:創建集合對象
 *         C:讀取數據，每次讀取一行數據，把該行數據作為一個元素存儲到集合中
 *         D:釋放資源
 *         E:遍歷集合
 */
public class FileToArrayListTest {
    public static void main(String[] args) throws IOException {
        //創建輸入緩沖流對象
        BufferedReader br = new  BufferedReader(new FileReader("array.txt"));
        
        //創建集合對象
        ArrayList<String> array = new ArrayList<String>();
        
        //讀取數據，每次讀取一行數據，把該行數據作為一個元素存儲到集合中
        String line;
        while((line=br.readLine())!=null) {
            array.add(line);
        }
        
        //釋放資源
        br.close();
        
        //遍歷集合
        for(int x=0; x<array.size(); x++) {
            String s = array.get(x);
            System.out.println(s);
        }
    }
}

Java 之IO流及應用