java 文件系統

文件系統：

文件系統是操作系統操作設備上文件和數據結構的方法。操作系統中負責管理文件信息的軟件單元叫文件管理系統，簡稱文件系統，文件系統由三部分組成：文件系統的接口，對象操作和管理的軟件集合和對象及屬性。文件系統主要解決信息的長期存儲。

文件：

文件是信息存儲的形式，一個文件是一個命名的，存儲在設備上的信息的線性字節流。文件在需要的時候可以讀取這些信息或者寫入新的信息。存儲在文件中的信息是永久的。文件系統中最重要的就是如何呈現一個文件信息：文件屬性----文件由什麼組成，如何命名，如何保護文件；文件操作---增刪改查及如何組織存儲。

從用戶的角度，主要關注文件怎麼使用和特徵。

文件特徵：

命名：

文件最大的特徵就是命名，文件的操作都是基於命名。

數據：

數據是文件信息的存儲。

還有一些屬性：創建日期，文件長度，創建信息，文件權限等

文件操作：

創建文件：創建沒有任何信息的文件，知識神明文件存在，並附加一些屬性。

刪除文件：釋放文件存儲空間。

打開文件：讀取文件之前需要先打開文件，文件系統內存中保留打開文件的一些信息，又是會創建對文件存取的相關機制

關閉文件：關閉文件可以將內存中的一些信息寫回文件，並釋放打開文件佔用資源

讀文件：一般是從當前位置讀取數據到一個緩存區

寫文件：向文件中寫入信息數據

追加數據：在文件末尾添加信息數據

讀記錄：在結構化文件中讀取記錄

寫記錄：在結構化文件中寫入記錄

刪除記錄：在結構化文件中刪除記錄

移動當前位置：將文件操作文位置移動到特定位置

獲取文件屬性：

設置文件屬性：

文件名修改：

目錄：

目錄可以理解爲文件的集合或者容器。多個文件可以存儲在一個目錄下。

所有的文件操作都是文件系統提供的功能，在使用文件操作功能前，需要加載文件系統。

java I/O

Java IO 體系看起來類很多，感覺很複雜，但其實是 IO 涉及的因素太多了。在設計 IO 相關的類時，編寫者也不是從同一個方面考慮的，所以會給人一種很亂的感覺，並且還有設計模式的使用，更加難以使用這些 IO 類，所以特地對 Java 的 IO 做一個總結。

IO 類設計出來，肯定是爲了解決 IO 相關的操作的，想一想哪裏會有 IO 操作？網絡、磁盤。網絡操作相關的類是在 java.net 包下，不在本文的總結範圍內。提到磁盤，你可能會想到文件，文件操作在 IO 中是比較典型的操作.

在 Java 中引入了 “流” 的概念，它表示任何有能力產生數據源或有能力接收數據源的對象，數據傳輸以不同的運輸方式對應不同的運輸特性。

數據源I/O:

1、文件（file）：FileInputStream、FileOutputStream、FileReader、FileWriter
2、數組（[]）：
- 2.1、字節數組（byte[]）：ByteArrayInputStream、ByteArrayOutputStream
- 2.2、字符數組（char[]）：CharArrayReader、CharArrayWriter
3、管道操作：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter
4、基本數據類型：DataInputStream、DataOutputStream
5、緩衝操作：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
6、打印：PrintStream、PrintWriter
7、對象序列化反序列化：ObjectInputStream、ObjectOutputStream
8、轉換：InputStreamReader、OutputStreWriter

數據傳輸方式：

1、字節流
2、字符流

IO 類雖然很多，但最基本的是 4 個抽象類：InputStream、OutputStream、Reader、Writer。最基本的方法也就是一個讀 read() 方法、一個寫 write() 方法。方法具體的實現還是要看繼承這 4 個抽象類的子類，畢竟我們平時使用的也是子類對象

InputStream 類

方法	方法介紹
public abstract int read()	讀取數據
public int read(byte b[])	將讀取到的數據放在 byte 數組中，該方法實際上是根據下面的方法實現的，off 爲 0，len 爲數組的長度
public int read(byte b[], int off, int len)	從第 off 位置讀取 len 長度字節的數據放到 byte 數組中，流是以 -1 來判斷是否讀取結束的（注意這裏讀取的雖然是一個字節，但是返回的卻是 int 類型 4 個字節，這裏當然是有原因，這裏就不再細說了，推薦這篇文章，鏈接）
public long skip(long n)	跳過指定個數的字節不讀取，想想看電影跳過片頭片尾
public int available()	返回可讀的字節數量
public void close()	讀取完，關閉流，釋放資源
public synchronized void mark(int readlimit)	標記讀取位置，下次還可以從這裏開始讀取，使用前要看當前流是否支持，可以使用 markSupport() 方法判斷
public synchronized void reset()	重置讀取位置爲上次 mark 標記的位置
public boolean markSupported()	判斷當前流是否支持標記流，和上面兩個方法配套使用

OutputStream 類

方法	方法介紹
public abstract void write(int b)	寫入一個字節，可以看到這裏的參數是一個 int 類型，對應上面的讀方法，int 類型的 32 位，只有低 8 位才寫入，高 24 位將捨棄。
public void write(byte b[])	將數組中的所有字節寫入，和上面對應的 read() 方法類似，實際調用的也是下面的方法。
public void write(byte b[], int off, int len)	將 byte 數組從 off 位置開始，len 長度的字節寫入
public void flush()	強制刷新，將緩衝中的數據寫入
public void close()	關閉輸出流，流被關閉後就不能再輸出數據了

再來看 Reader 和 Writer 類中的方法，你會發現和上面兩個抽象基類中的方法很像。

Reader 類

方法	方法介紹
public int read(java.nio.CharBuffer target)	讀取字節到字符緩存中
public int read()	讀取單個字符
public int read(char cbuf[])	讀取字符到指定的 char 數組中
abstract public int read(char cbuf[], int off, int len)	從 off 位置讀取 len 長度的字符到 char 數組中
public long skip(long n)	跳過指定長度的字符數量
public boolean ready()	和上面的 available() 方法類似
public boolean markSupported()	判斷當前流是否支持標記流
public void mark(int readAheadLimit)	標記讀取位置，下次還可以從這裏開始讀取，使用前要看當前流是否支持，可以使用 markSupport() 方法判斷
public void reset()	重置讀取位置爲上次 mark 標記的位置
abstract public void close()	關閉流釋放相關資源

Writer 類

方法	方法介紹
public void write(int c)	寫入一個字符
public void write(char cbuf[])	寫入一個字符數組
abstract public void write(char cbuf[], int off, int len)	從字符數組的 off 位置寫入 len 數量的字符
public void write(String str)	寫入一個字符串
public void write(String str, int off, int len)	從字符串的 off 位置寫入 len 數量的字符
public Writer append(CharSequence csq)	追加吸入一個字符序列
public Writer append(CharSequence csq, int start, int end)	追加寫入一個字符序列的一部分，從 start 位置開始，end 位置結束
public Writer append(char c)	追加寫入一個 16 位的字符
abstract public void flush()	強制刷新，將緩衝中的數據寫入
abstract public void close()	關閉輸出流，流被關閉後就不能再輸出數據了

下面我們就直接使用他們的子類，在使用中再介紹下面沒有的新方法。

1、讀取控制檯中的輸入

import java.io.*;

public class IOTest {
    public static void main(String[] args) throws IOException {
        // 三個測試方法
//        test01();
//        test02();
        test03();
    }

    public static void test01() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("請輸入一個字符");
        char c;
        c = (char) bufferedReader.read();
        System.out.println("你輸入的字符爲"+c);
    }

    public static void test02() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("請輸入一個字符，按 q 鍵結束");
        char c;
        do {
            c = (char) bufferedReader.read();
            System.out.println("你輸入的字符爲"+c);
        } while (c != 'q');
    }

    public static void test03() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("請輸入一行字符");
        String str = bufferedReader.readLine();
        System.out.println("你輸入的字符爲" + str);
    }
}

至於控制檯的輸出，我們其實一直都在使用呢，System.out.println() ，out 其實是 PrintStream 類對象的引用，PrintStream 類中當然也有 write() 方法，但是我們更常用 print() 方法和 println() 方法，因爲這兩個方法可以輸出的內容種類更多，比如一個打印一個對象，實際調用的對象的 toString() 方法。

2、二進制文件的寫入和讀取

注意這裏文件的路徑，可以根據自己情況改一下，雖然這裏的文件後綴是txt，但該文件卻是一個二進制文件，並不能直接查看。

@Test
    public void test04() throws IOException {
        byte[] bytes = {12,21,34,11,21};
        FileOutputStream fileOutputStream = new FileOutputStream(new File("").getAbsolutePath()+"/io/test.txt");
        // 寫入二進制文件，直接打開會出現亂碼
        fileOutputStream.write(bytes);
        fileOutputStream.close();
    }

    @Test
    public void test05() throws IOException {
        FileInputStream fileInputStream = new FileInputStream(new File("").getAbsolutePath()+"/io/test.txt");
        int c;
        // 讀取寫入的二進制文件，輸出字節數組
        while ((c = fileInputStream.read()) != -1) {
            System.out.print(c);
        }
    }

3、文本文件的寫入和讀取

write() 方法和 append() 方法並不是像方法名那樣，一個是覆蓋內容，一個是追加內容，append() 內部也是 write() 方法實現的，也非說區別，也就是 append() 方法可以直接寫 null，而 write() 方法需要把 null 當成一個字符串寫入，所以兩者並無本質的區別。需要注意的是這裏並沒有指定文件編碼，可能會出現亂碼的問題。

@Test
    public void test06() throws IOException {
        FileWriter fileWriter = new FileWriter(new File("").getAbsolutePath()+"/io/test.txt");
        fileWriter.write("Hello，world！\n歡迎來到 java 世界\n");
        fileWriter.write("不會覆蓋文件原本的內容\n");
//        fileWriter.write(null); 不能直接寫入 null
        fileWriter.append("並不是追加一行內容，不要被方法名迷惑\n");
        fileWriter.append(null);
        fileWriter.flush();
        System.out.println("文件的默認編碼爲" + fileWriter.getEncoding());
        fileWriter.close();
    }

    @Test
    public void test07() throws IOException {
        FileWriter fileWriter = new FileWriter(new File("").getAbsolutePath()+"/io/test.txt", false); // 關閉追加模式，變爲覆蓋模式
        fileWriter.write("Hello，world！歡迎來到 java 世界\n");
        fileWriter.write("我來覆蓋文件原本的內容");
        fileWriter.append("我是下一行");
        fileWriter.flush();
        System.out.println("文件的默認編碼爲" + fileWriter.getEncoding());
        fileWriter.close();
    }

    @Test
    public void test08() throws IOException {
        FileReader fileReader = new FileReader(new File("").getAbsolutePath()+"/io/test.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String str;
        while ((str = bufferedReader.readLine()) != null) {
            System.out.println(str);
        }
        fileReader.close();
        bufferedReader.close();
    }

    @Test
    public void test09() throws IOException {
        FileReader fileReader = new FileReader(new File("").getAbsolutePath()+"/io/test.txt");
        int c;
        while ((c = fileReader.read()) != -1) {
            System.out.print((char) c);
        }
    }

使用字節流和字符流的轉換類 InputStreamReader 和 OutputStreamWriter 可以指定文件的編碼，使用 Buffer 相關的類來讀取文件的每一行。

@Test
    public void test10() throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream(new File("").getAbsolutePath()+"/io/test2.txt");
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "GBK"); // 使用 GBK 編碼文件
        outputStreamWriter.write("Hello，world！\n歡迎來到 java 世界\n");
        outputStreamWriter.append("另外一行內容");
        outputStreamWriter.flush();
        System.out.println("文件的編碼爲" + outputStreamWriter.getEncoding());
        outputStreamWriter.close();
        fileOutputStream.close();
    }

    @Test
    public void test11() throws IOException {
        FileInputStream fileInputStream = new FileInputStream(new File("").getAbsolutePath()+"/io/test2.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "GBK"); // 使用 GBK 解碼文件
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String str;
        while ((str = bufferedReader.readLine()) != null) {
            System.out.println(str);
        }
        bufferedReader.close();
        inputStreamReader.close();
    }

4、複製文件

這裏筆者做了一些測試，不使用緩衝對文件複製時間的影響，文件的複製實質還是文件的讀寫。緩衝流是處理流，是對節點流的裝飾。

注：這裏的時間是在我這臺華碩筆記本上測試得到的，只是爲了說明使用緩衝對文件的讀寫有好處。

@Test
    public void  test12() throws IOException {
        // 輸入和輸出都使用緩衝流
        FileInputStream in = new FileInputStream("E:\\視頻資料\\大數據原理與應用\\1.1大數據時代.mp4");
        BufferedInputStream inBuffer = new BufferedInputStream(in);
        FileOutputStream out = new FileOutputStream("1.1大數據時代.mp4");
        BufferedOutputStream outBuffer = new BufferedOutputStream(out);
        int len = 0;
        byte[] bs = new byte[1024];
        long begin = System.currentTimeMillis();
        while ((len = inBuffer.read(bs)) != -1) {
            outBuffer.write(bs, 0, len);
        }
        System.out.println("複製文件所需的時間：" + (System.currentTimeMillis() - begin)); // 平均時間約 200 多毫秒
        inBuffer.close();
        in.close();
        outBuffer.close();
        out.close();
    }


    @Test
    public void  test13() throws IOException {
        // 只有輸入使用緩衝流
        FileInputStream in = new FileInputStream("E:\\視頻資料\\大數據原理與應用\\1.1大數據時代.mp4");
        BufferedInputStream inBuffer = new BufferedInputStream(in);
        FileOutputStream out = new FileOutputStream("1.1大數據時代.mp4");
        int len = 0;
        byte[] bs = new byte[1024];
        long begin = System.currentTimeMillis();
        while ((len = inBuffer.read(bs)) != -1) {
            out.write(bs, 0, len);
        }
        System.out.println("複製文件所需時間：" + (System.currentTimeMillis() - begin)); // 平均時間約 500 多毫秒
        inBuffer.close();
        in.close();
        out.close();
    }

    @Test
    public void test14() throws IOException {
        // 輸入和輸出都不使用緩衝流
        FileInputStream in = new FileInputStream("E:\\視頻資料\\大數據原理與應用\\1.1大數據時代.mp4");
        FileOutputStream out = new FileOutputStream("1.1大數據時代.mp4");
        int len = 0;
        byte[] bs = new byte[1024];
        long begin = System.currentTimeMillis();
        while ((len = in.read(bs)) != -1) {
            out.write(bs, 0, len);
        }
        System.out.println("複製文件所需時間：" + (System.currentTimeMillis() - begin)); // 平均時間 700 多毫秒
        in.close();
        out.close();
    }

    @Test
    public void test15() throws IOException {
        // 不使用緩衝
        FileInputStream in = new FileInputStream("E:\\視頻資料\\大數據原理與應用\\1.1大數據時代.mp4");
        FileOutputStream out = new FileOutputStream("1.1大數據時代.mp4");
        int len = 0;
        long begin = System.currentTimeMillis();
        while ((len = in.read()) != -1) {
            out.write(len);
        }
        System.out.println("複製文件所需時間：" + (System.currentTimeMillis() - begin)); // 平均時間約 160000 毫秒，約 2 分多鐘
        in.close();
        out.close();
    }

NiFi vs StreamSets(SDC)

spring 彙總 -----spring events

splunk簡介

flink源碼閱讀---DataStream API編程指南

flink源碼閱讀---DataStream數據架構描述1-core底層架構

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結