不用懷疑！這就是把Java.I/O流講解的最清楚的一篇文章

本文目錄

簡單梳理

理解

對於文件流來講是io流的基礎，牽扯到緩衝流，緩衝流是在內存中使用io流的各種操做，轉換流顧名思義，是字節與字符流之間的轉換 ，要先有字節流和字符流，對象流，最主要的是類的序列化與反序列化，至關於一個封裝轉化，隨機存取流，也是在有字節流和字符流的基礎上。

File類

能新建，刪除，重命名文件和目錄，但不能訪問文件內容，訪問文件內容要經過輸入/輸出流

簡單梳理

File操做

package day12;

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
    File f = new File("D:\\test\\abc\\tt.txt");//這個時候對象f就是tt.txt文件
    File f4 = new File("D:\\test\\abc");//這個目錄
    <!-- File f2 = new File("D:/test/abc/tt.txt");
    File f3 = new File("D:" + File.separator + "test\\abc\\tt.txt");
    File f1 = new File("D:\\test","abc\\tt.txt");//這個f1也是tt.txt文件，這種實驗相對比較少 -->

    //注意，\在文件中是路徑的分隔符，可是在java編程中一個\的意思是轉移符，在java中\\或者/纔是文件的分隔符
    //也能夠File.separator做爲文件分隔符
    System.out.println(f.getName());//獲取文件名
    System.out.println(f4.getName());//獲取文當前的文件名稱

    File f5 = new File("src/day12/Test.java");//使用相對路徑來建立file對象

    System.out.println(f5.getPath());//獲取文件或者文件夾的路徑，就是new file時候寫的路徑
    System.out.println(f5.getAbsolutePath());//獲取當前文件的絕對路徑

    System.out.println(f5);
    System.out.println(f5.getAbsoluteFile());//返回一個用當前的文件的絕對路徑構建的file對象

    System.out.println(f5.getParent());//返回當前文件或者文件夾的父級路徑

            f.renameTo(new File("D:\\test\\abc\\tt1.txt"));//給文件或文件夾重命名

    File f6 = new File("D:\\test\\abc1");
    System.out.println(f6.exists());//判斷文件或者文件夾是否存在

    File f7 = new File("D:\\test\\abc\\tt1.txt");
    System.out.println(f7.canWrite());//判斷文件是否可寫
    System.out.println(f7.canRead());//判斷文件是否可讀

    System.out.println(f7.isFile());//判斷當前的file對象是否是文件
    System.out.println(f7.isDirectory());//判斷當前的file對象是否是文件夾或者目錄

    System.out.println(f7.lastModified());//獲取文件的最後修改時間，返回的是一個毫秒數
    System.out.println(f7.length());//返回文件的長度，單位是字節數

    File f8 = new File("D:\\test\\abc\\tt2.txt");
    System.out.println(f8.exists());//判斷文件是否存在
    if(!f8.exists()){
        try {
            f8.createNewFile();//建立新的文件
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    <!-- f8.delete();//刪除文件

    File f9 = new File("D:\\test\\abc\\cc");
    File f9 = new File("D:\\test\\abc\\cc\\dd");

    f9.mkdir();//建立單層目錄，若是使用這一方法來建立多層目錄，就得一層一層的執行mkdir()

    File f10 = new File("D:\\test\\abc\\a\\b\\c");

    f10.mkdirs();//這個方法是直接用來建立多層目錄 -->

    File f11 = new File("D:\\test");
    String[] fl = f11.list();//返回的是當前文件夾的子集的名稱，包括目錄和文件
    for(String s : fl){
        System.out.println(s);
    }

    File[] fs = f11.listFiles();//返回的是當前文件夾的子集的file對象，包括目錄和文件
    for(File ff : fs){
        System.out.println(ff);
    }
}

遞歸遍歷文件

public void test(File file){
        if(file.isFile()){
            System.out.println(file.getAbsolutePath() + " 是文件");
        }else{
            System.out.println(file.getAbsolutePath() + " 是文件夾");
            //若是是文件夾，這個文件夾裏就可能有子文件夾或者文件
            File[] fs = file.listFiles();//獲取當前文件夾下的子文件夾或者文件的file對象
            if(fs != null && fs.length > 0){
                for(File ff : fs){

                    test(ff);//遞歸

                    if(ff.isFile()){
                        System.out.println(ff.getAbsolutePath() + " 是文件");
                    }else{
                        System.out.println(ff.getAbsolutePath() + " 是文件夾");
                        File[] fs1 = ff.listFiles();
                        if(fs1 != null && fs1.length > 0){
                            for(File ff1 : fs1){

                            }
                        }
                    }

                }
            }

        }
    }
}

文件流：數據流的讀寫都是基於文件的操做

字節流很是通用，能夠用來操做字符的文檔，還能夠操做而後的其餘類型文件，都是使用二進制轉換

FileInputStream：字節輸入流

public static void testFileInputStream(){
    try {
        FileInputStream in = new FileInputStream("D:/test/abc/tt1.txt");

        byte[] b = new byte[10];//設置一個byte數組接收讀取的文件的內容

        int len = 0;//設置一個讀取數據的長度

        //in.read(b);//in.read方法有一個返回值，返回值是讀取的數據的長度，若是讀取到最後一個數據，還會向後讀一個，這個時候返回值就是-1
        //也就意味着當in.read的返回值是-1的時候整個文件就讀取完畢了

        while((len = in.read(b)) != -1){
            System.out.println(new String(b,0,len));
            //new String(b,0,len),參數1是緩衝數據的數組，參數2是從數組的那個位置開始轉化字符串，參數3是總共轉化幾個字節
        }

        in.close();//注意。流在使用完畢以後一段要關閉
    } catch (Exception e) {
        e.printStackTrace();
    }
}

FileOutputStream：字節輸出流

public static void testFileOutputStream(){
    try {
        FileOutputStream out = new FileOutputStream("D:/test/abc/tt4.txt");//指定行tt4輸出數據
        String str = "knsasjadkajsdkjsa";
        out.write(str.getBytes());//把數據寫到內存
        out.flush();//把內存中的數據刷寫到硬盤
        out.close();//關閉流

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

複製文件到指定位置

public static void copyFile(String inPath, String outPanth){
    try {
        FileInputStream in = new FileInputStream(inPath);//讀取的源文件

        FileOutputStream out = new FileOutputStream(outPanth);//複製到哪裏

        byte[] b = new byte[100];

        int len = 0;

        while((len = in.read(b)) != -1){
            out.write(b, 0, len);//參數1是寫的緩衝數組，參數2是從數組的那個位置開始，參數3是獲取的數組的總長度
        }

        out.flush();//把寫到內存的數據刷到硬盤
        out.close();
        in.close();

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

FileReader：字符輸入流

public static void testFileReader(String inPath){
    try {
        FileReader fr = new FileReader(inPath);//建立文件字符輸入流的對象

        char[] c = new char[10];//建立臨時存數據的字符數組

        int len = 0;//定義一個輸入流的讀取長度

        while((len = fr.read(c)) != -1){
            System.out.println(new String(c, 0, len));
        }

        fr.close();//關閉流

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

FileWriter：字符輸出流

public static void testFileWriter(String text,String outPath){
    try {
        FileWriter fw = new FileWriter(outPath);
        fw.write(text);//寫到內存中
        fw.flush();//把內存的數據刷到硬盤
        fw.close();//關閉流

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

複製文件到指定位置(字符流只適合操做內容是字符文件)

public static void copyFile(String inPaht, String outPath){
    try {
        FileReader fr = new FileReader(inPaht);
        FileWriter fw = new FileWriter(outPath);

        char[] c = new char[100];

        int len = 0;

        while((len = fr.read(c)) != -1){//讀取數據
            fw.write(c,0,len);//寫數據到內存
        }

        fw.flush();

        fw.close();
        fr.close();

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

緩衝流：數據流的讀寫都是基於內存的操做

• 緩衝流要套接在相應的節點流之上，對讀寫的數據提供了緩衝的功能，提升了讀寫的效率，同時增長了一些新的方法，對於輸出的緩衝流，寫出的數據會先在內存中緩存，使用flush()將會使內存中的數據馬上寫出
• 簡單來講就是先把數據緩存到內存裏，在內存中作io操做

BufferedInputStream：緩衝字節輸入流

public static void testBufferedInputStream() throws Exception {
    // 文件字節輸入流對象
    FileInputStream in = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt.txt");

    // 把文件字節輸入流放到緩衝字節輸入流對象
    BufferedInputStream br = new BufferedInputStream(in);

    byte[] b = new byte[10];

    int len = 0;

    while ((len = br.read(b)) != -1) {
        System.out.println(new String(b, 0, len));
    }

    // 關閉流的時候，本着一個最晚開的最先關，依次關
    br.close();
    in.close();
}

BufferedOutputStream：緩衝字節輸入流

public static void testBufferedOutputStream() throws Exception {
    // 建立字節輸出流對象
    FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt");

    // 把字節輸出流對象放到緩衝字節輸出流中
    BufferedOutputStream bo = new BufferedOutputStream(out);

    String s = "hello world";

    bo.write(s.getBytes());// 寫到內存中

    bo.flush();// 刷到硬盤上

    // 關閉流的時候，本着一個最晚開的最先關，依次關
    bo.close();
    out.close();
}

緩衝流實現文件的複製

public static void copyFile() throws Exception {
    // 緩衝輸入流
    BufferedInputStream br = new BufferedInputStream(
            new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt"));

    // 緩衝輸出流
    BufferedOutputStream bo = new BufferedOutputStream(
            new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt2.txt"));

    byte[] b = new byte[1024];

    int len = 0;// 設置一個沒出讀取到的數據的長度，直到br.read方法執行到最後（好比說文件中只有hello
                // world，執行到最後一個就讀取d的後面，這個時候返回值就是-1）

    while ((len = br.read(b)) != -1) {
        bo.write(b, 0, len);// 寫到內存
    }

    bo.flush();// 刷到硬盤

    bo.close();
    br.close();
}

BufferedReader：緩衝字符輸入流

public static void testBufferedReader() throws Exception {
    FileReader r = new FileReader("D:\\testdemo\\demo\\src\\day13\\tt.txt");

    BufferedReader br = new BufferedReader(r);

    char[] c = new char[100];

    int len = 0;

    while ((len = br.read(c)) != -1) {// br.read(c)讀到文件的最後一個字符的下一位，返回值就是-1
        System.out.println(new String(c, 0, len));
    }
    br.close();
    r.close();
}

BufferedWriter：緩衝字符輸出流

public static void testBufferedWriter() throws Exception {
    FileWriter fw = new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt3.txt");

    BufferedWriter bw = new BufferedWriter(fw);

    String s = "hello world!!!!";

    bw.write(s);

    bw.flush();

    bw.close();
    fw.close();
}

緩衝字符流複製文件

public static void copyFile() throws Exception {
    BufferedReader br = new BufferedReader(new FileReader("D:\\testdemo\\demo\\src\\day13\\tt3.txt"));

    BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt4.txt"));

    char[] c = new char[100];

    int len = 0;

    while ((len = br.read(c)) != -1) {
        bw.write(c, 0, len);
    }

    bw.flush();

    bw.close();
    br.close();
}

轉換流

• 轉換字節輸入流爲字符輸入流 注意，在轉換字符流的時候，設置的字符集編碼要與讀取的文件的數據的編碼一致 否則就會出現亂碼 InputStreamReader
• 全部的文件都是有編碼格式，對於咱們來講，TXT和java文件通常來說有三種編碼，ISO8859-1，西歐編碼，是純粹英文編碼，不適應漢字，GBK和UTF-8，這兩編碼是適用於重要和英文，咱們通常使用UTF-8編碼

InputStreamReader：轉換字節輸入流爲字符輸入流

public static void testInputStreamReader() throws Exception {
    FileInputStream fs = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt5.txt");

    // 把字節流轉換爲字符流
    InputStreamReader in = new InputStreamReader(fs, "GBK");// 參數1是字節流，參數2是編碼
    //InputStreamReader in = new InputStreamReader(fs,"UTF-8");//參數1是字節流，參數2是編碼

    char[] c = new char[100];
    int len = 0;

    while ((len = in.read(c)) != -1) {
        System.out.println(new String(c, 0, len));
    }

    in.close();
    fs.close();
}

OutputStreamReader：轉換字節輸出流爲字符輸出流

public static void testOutputStreamWriter() throws Exception {
    FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt6.txt");

    //OutputStreamWriter os = new OutputStreamWriter(out, "UTF-8");
    OutputStreamWriter os = new OutputStreamWriter(out, "GBK");

    os.write("你好你好");
    os.flush();

    os.close();
    out.close();
}

標準輸入輸出流

• System.in(默認輸入鍵盤)：類型是InputStream
• System.out(默認輸出顯示器)：類型是PrintStream，是OutputStream的子類FilterOutputStream的子類

標準的輸入流

public static void testSystemIn() throws Exception {
    // 建立一個接收鍵盤輸入數據的輸入流
    InputStreamReader is = new InputStreamReader(System.in);

    // 把輸入流放到緩衝流裏
    BufferedReader br = new BufferedReader(is);

    String str = "";// 定義一個臨時接收數據的字符串

    while ((str = br.readLine()) != null) {
        System.out.println(str);
    }

    br.close();
    is.close();
}

把控制檯輸入的內容寫到指定的TXT文件中，當接收到字符串over，就結束程序的運行

public static void write2TXT() throws Exception {
    // 建立一個接收鍵盤輸入數據的輸入流
    InputStreamReader is = new InputStreamReader(System.in);

    // 把輸入流放到緩衝流裏
    BufferedReader br = new BufferedReader(is);

    BufferedWriter out = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt7.txt"));

    String line = "";

    while ((line = br.readLine()) != null) {
        if (line.equals("over")) {
            break;
        }
        // 讀取的每一行都寫到指定的TXT文件
        out.write(line);
    }

    out.flush();
    out.close();
    br.close();
    is.close();

}

打印流(瞭解)

PrintStream/PrintWriter:System.out.println等

數據流(瞭解)：專門用來作基本數據類型的讀寫的

DataInputStream：數據輸出流

用數據輸出流寫到文件的中的基本數據類型的數據，是亂碼的，不能直接辨認出來，須要數據輸入流來讀取 DataOutputStream

public static void testDataOutputStream() throws Exception {
    DataOutputStream out = new DataOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt8.txt"));

    //out.writeBoolean(true);
    out.writeDouble(1.35d);
    //out.writeInt(100);

    out.flush();
    out.close();

}

DataOutputStream：數據輸入流

若是寫的時候是writeDouble，讀的時候就得是readDouble DataInputStream

public static void testDataInputStream() throws Exception {
    DataInputStream in = new DataInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt8.txt"));

    System.out.println(in.readDouble());

    in.close();
}

對象流(序列化與反序列化):把一個對象轉化爲一個數據流進行讀寫

ObjectInputStream：對象的序列化

public static void testSerialize() throws Exception {
    // 定義對象的輸出流，把對象的序列化以後的流放到指定的文件中
    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt9.txt"));

    Person p = new Person();
    p.name = "zhangsan";
    p.age = 11;

    out.writeObject(p);
    out.flush();// 刷寫數據到硬盤

    out.close();
}

ObjectOutputStream：對象的反序列化

public static void testDeserialize() throws Exception {
    // 建立對象輸入流對象，從指定的文件中把對象序列化後的流讀取出來
    ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt9.txt"));

    Object obj = in.readObject();

    Person p = (Person) obj;

    // 這個時候序列化與反序列化使用的類不是一個類分別是day13.Person和day13.test.Person
    // 這個時候反序列化就有異常day13.Person cannot be cast to day13.test.Person
    //day13.test.Person p = (day13.test.Person)obj;

    System.out.println(p.name);
    System.out.println(p.age);

    in.close();

}

RandomAccessFile：隨意存取文件流:插入位置，讀取位置，存儲位置隨意

• RandomAccessFile的構造有兩個參數，參數1是讀寫的文件的路徑
• 參數2是指定 RandomAccessFile 的訪問模式
• r: 以只讀方式打開
• rw：打開以便讀取和寫入
• rwd:打開以便讀取和寫入；同步文件內容的更新
• rws:打開以便讀取和寫入；同步文件內容和元數據的更新
• 最經常使用是r和rw

隨意讀文件

public static void testRandomAccessFileRead() throws Exception {
    RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "r");

    //ra.seek(0);//設置讀取文件內容的起始點
    ra.seek(8);// 經過設置讀取文件內容的起始點，來達到從文件的任意位置讀取

    byte[] b = new byte[1024];

    int len = 0;

    while ((len = ra.read(b)) != -1) {
        System.out.println(new String(b, 0, len));
    }

    ra.close();
}

隨意存文件

public static void testRandomAccessFileWrite() throws Exception {
    RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "rw");

    //ra.seek(0);//設置寫的起始點，0表明從開頭寫
    // 注意：若是是在文件開頭或者中間的某個位置開始寫的話，就會用寫的內容覆蓋掉等長度的原內容
    ra.seek(ra.length());// 設置寫的起始點,ra.length()表明從文件的最後結尾寫，也就是文件的追加

    ra.write("你好".getBytes());

    ra.close();
}