@Test
public void test1() {
    // 造一個讀取的流，聲明在這是為了finally要關，所以先賦null(沒有實際造)
    FileReader reader = null;
    try {
        // 指定要作為流的起點的檔案
        File file1 = new File("hi.txt");
        // 將檔案作為形參，傳入構造器，實際造流
        reader = new FileReader(file1);
        // .read()方法按順序讀出一個一個int形式的char，直到沒東西了返回-1
        int data;
        while ((data = reader.read()) != -1) {
            System.out.print(((char) data));
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 永遠記得開了流就要關
        try {
            // 關閉前先判斷是否為"一開始就沒進去實際造"的null
            if (reader != null) reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

try {
    // 指定要作為流的起點的檔案
    File file1 = new File("hi.txt");
    // 將檔案作為形參，傳入構造器，實際造
    reader = new FileReader(file1);
    // .read(cbuf)方法按順序讀出一個一個char[]形式的數組，
    // 返回讀出的char數量，直到沒東西了返回-1
    char[] cbuf = new char[5]; // 假設一次拿5個char出來
    int len; // 用來接收拿出來的數量
    while ((len = reader.read(cbuf)) != -1) {
        for (int i = 0; i < len; i++) {
            // 注意這個for循環不能寫i < cbuf.length，否則拿到不滿5個時會出錯
            // "錯誤"不是空指針，而是會重複輸出上一輪的後幾個字
            System.out.print(cbuf[i]);
        }
        // 再改進，取代上面的for，直接用String裝
        String str = new String(cbuf, 0, len);
        System.out.print(str);
    }
}

FileWriter writer = null;
try {
    File file2 = new File("file2.txt");
    writer = new FileWriter(file2, true); // 參數append預設是false
    writer.write("something...");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        assert writer != null;
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Test
public void test3() throws Exception { // 偷懶先拋個異常
    File f3 = new File("hi.txt");
    FileInputStream fileInputStream = new FileInputStream(f3);
    byte[] buf = new byte[5];
    int n = 0;
    while ((n = fileInputStream.read(buf)) != -1) {
        String str = new String(buf, 0, n);
        System.out.print(str);
    }
    fileInputStream.close();
}

@Test
public void test4() {
    FileInputStream inputStream = null;
    FileOutputStream outputStream = null;
    try {
        File src = new File("pic.png");
        File dest = new File("newpic.png");
        inputStream = new FileInputStream(src);
        outputStream = new FileOutputStream(dest);
        byte[] buf = new byte[5];
        int len;
        while ((len = inputStream.read(buf)) != -1) {
            outputStream.write(buf,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            assert inputStream != null; // 並列寫完全OK，反正都是要關
            inputStream.close();
            assert outputStream != null;
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

@Test
public void bufferTest1() {
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    BufferedInputStream bufferedInputStream = null;
    BufferedOutputStream bufferedOutputStream = null;
    try {
        File src = new File("陳菊.avi");
        File dest = new File("陳菊2.avi");

        fileInputStream = new FileInputStream(src);
        fileOutputStream = new FileOutputStream(dest);

        // 造緩衝流
        bufferedInputStream = new BufferedInputStream(fileInputStream);
        bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

        // 用緩衝流操作
        byte[] buf = new byte[1024];
        int len;
        while ((len = bufferedInputStream.read(buf)) != -1) {
            bufferedOutputStream.write(buf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        // 關閉流，穿脫衣服原則，後穿的先脫
        try {
            assert bufferedOutputStream != null;
            bufferedOutputStream.close();
            assert bufferedInputStream != null;
            bufferedInputStream.close();

            // 其實關閉外層流就把內層的也關了，所以可省略
            fileOutputStream.close();
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

@Test
public void picLock() {
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    try {
        // 在流的構造參數直接寫路徑相當於new一個File物件並包裝起來傳入，懶人福音
        fileInputStream = new FileInputStream("pic.png");
        fileOutputStream = new FileOutputStream("lockedPic.png");
        byte[] buf = new byte[10];
        int len;
        while ((len = fileInputStream.read(buf)) != -1) {
            // 進行加密修改字節，注意不是用foreach，那是讀出數據賦到一個暫時變量=白改
            for (int i = 0; i < buf.length; i++) {
                byte b = buf[i];
                b = (byte) (b ^ 5); // 異或，兩者不同為true
                buf[i] = b;
            }
            fileOutputStream.write(buf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fileInputStream.close();
            fileOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}