JavaSE基礎知識分享(十)

ikestu小猪發表於2024-08-19

Java

寫在前面

今天繼續講JavaIO流的知識！

Java 檔案與流操作

File 類

File 類用於表示檔案和資料夾的抽象。

構造方法

public File(String pathname): 使用路徑名建立 File 物件。
public File(String parent, String child): 使用父目錄和子目錄名稱建立 File 物件。
public File(File parent, String child): 使用父 File 物件和子目錄名稱建立 File 物件。

成員方法

建立功能

public boolean createNewFile(): 建立一個新檔案。
public boolean mkdir(): 建立單個目錄。
public boolean mkdirs(): 建立目錄，包括必要但不存在的父目錄。

刪除功能

public boolean delete(): 刪除檔案或目錄。

重新命名功能

public boolean renameTo(File dest): 重新命名檔案或目錄。

判斷功能

public boolean isDirectory(): 判斷是否為目錄。
public boolean isFile(): 判斷是否為檔案。
public boolean exists(): 判斷檔案或目錄是否存在。
public boolean canRead(): 判斷是否可讀。
public boolean canWrite(): 判斷是否可寫。
public boolean isHidden(): 判斷是否為隱藏檔案。

基本獲取功能

public String getAbsolutePath(): 獲取絕對路徑。
public String getPath(): 獲取路徑。
public String getName(): 獲取檔名。
public long length(): 獲取檔案長度。
public long lastModified(): 獲取最後修改時間。

高階獲取功能

public String[] list(): 獲取目錄中的檔案和目錄名稱。
public File[] listFiles(): 獲取目錄中的 File 物件陣列。

檔名稱過濾器

public String[] list(FilenameFilter filter): 使用檔名過濾器獲取檔案和目錄名稱。
public File[] listFiles(FilenameFilter filter): 使用檔名過濾器獲取 File 物件陣列。

位元組流

位元組輸入流

抽象父類: InputStream

實現子類:

FileInputStream

建立物件的方式：

FileInputStream fis = new FileInputStream("路徑");

讀取資料的方式：

一次讀取一個位元組：

int i = 0;
while ((i = fis.read()) != -1) {
    System.out.print((char) i);
}

一次讀取一個位元組陣列：

byte[] bytes = new byte[1024];
int length = 0;
while ((length = fis.read(bytes)) != -1) {
    String s = new String(bytes, 0, length）;
    System.out.print(s);
}

一次讀取一個位元組陣列的一部分。

byte[] bytes = new byte[1024];
int length = 0;
while ((length = fis.read(bytes)) != -1) {
    String s = new String(bytes, 這裡寫從哪個索引開始擷取, 這裡寫自己想要擷取的長度);
    System.out.print(s);
}

BufferedInputStream

建立物件的方式：

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("路徑"));

讀取資料的方式：

一次讀取一個位元組：

int i = 0;
while ((i = bis.read()) != -1) {
    System.out.print((char) i);
}

一次讀取一個位元組陣列：

byte[] bytes = new byte[1024];
int length = 0;
while ((length = bis.read(bytes)) != -1) {
    String s = new String(bytes, 0, length);
    System.out.print(s);
}

一次讀取一個位元組陣列的一部分。

byte[] bytes = new byte[1024];
int length = 0;
while ((length = bis.read(bytes)) != -1) {
    String s = new String(bytes, 這裡寫從哪個索引開始擷取, 這裡寫自己想要擷取的長度);
    System.out.print(s);
}

位元組輸出流

抽象父類: OutputStream

實現子類:

FileOutputStream

建立物件的方式：

#建立檔案輸出流以寫入由指定的 File物件表示的檔案。
FileOutputStream(File file) 


#建立檔案輸出流以寫入由指定的 File物件表示的檔案。  
FileOutputStream(File file, boolean append) 


#建立檔案輸出流以指定的名稱寫入檔案。  
FileOutputStream(String name) 


#建立檔案輸出流以指定的名稱寫入檔案。 
FileOutputStream(String name, boolean append)

寫資料的方式：

寫一個位元組：
```
fos.write(i);
```

寫一個位元組陣列：

byte[] bytes = {97, 98, 99};
fos.write(bytes);

寫位元組陣列的一部分：

byte[] bytes = {97, 98, 99};
fos.write(bytes, 1, 2);

BufferedOutputStream
- 建立物件的方式：
```
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("路徑"));
```
- 寫資料的方式（注：這種方式寫檔案在寫完之後需要flush一下，不然不會成功寫入，後面說的以file物件進行傳入引數的輸入流基本上都要寫完刷一下才有內容寫入）：
  - 寫一個位元組：
```
bos.write(i);
```
  - 寫一個位元組陣列：
```
byte[] bytes = {97, 98, 99};
bos.write(bytes);
```
  - 寫位元組陣列的一部分：
```
byte[] bytes = {97, 98, 99};
bos.write(bytes, 1, 2);
```

字元流

字元流是基於位元組流的，並加上了編碼表的支援。

字元輸入流

抽象父類: Reader

實現子類:

InputStreamReader

建立物件的方式：

InputStreamReader isr = new InputStreamReader(new FileInputStream("路徑"));

讀取資料的方式：

一次讀取一個字元：

int i = 0;
while ((i = isr.read()) != -1) {
    System.out.print((char) i);
}

一次讀取一個字元陣列：

char[] chars = new char[1024];
int length = 0;
while ((length = isr.read(chars)) != -1) {
    String s = new String(chars, 0, length);
    System.out.print(s);
}

一次讀取一個字元陣列的一部分。

char[] chars = new char[1024];
int length = 0;
while ((length = isr.read(chars)) != -1) {
    String s = new String(chars, 開始索引, 要讀的具體長度);
    System.out.print(s);
}

FileReader

建立物件的方式：

FileReader fr = new FileReader("路徑");

讀取資料的方式：

一次讀取一個字元：

int i = 0;
while ((i = fr.read()) != -1) {
    System.out.print((char) i);
}

一次讀取一個字元陣列：

char[] chars = new char[1024];
int length = 0;
while ((length = fr.read(chars)) != -1) {
    String s = new String(chars, 0, length);
    System.out.print(s);
}

一次讀取一個字元陣列的一部分。

char[] chars = new char[1024];
int length = 0;
while ((length = fr.read(chars)) != -1) {
    String s = new String(chars, 開始索引, 要讀的具體長度);
    System.out.print(s);
}

BufferedReader

建立物件的方式：

方式1：

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("路徑")));

方式2（簡化版）：

BufferedReader br = new BufferedReader(new FileReader("路徑"));

讀取資料的方式：

一次讀取一個字元：

int i = 0;
while ((i = br.read()) != -1) {
    System.out.print((char) i);
}

一次讀取一個字元陣列：

char[] chars = new char[1024];
int length = 0;
while ((length = br.read(chars)) != -1) {
    String s = new String(chars, 0, length);
    System.out.print(s);
}

一次讀取一個字元陣列的一部分。

char[] chars = new char[1024];
int length = 0;
while ((length = br.read(chars)) != -1) {
    String s = new String(chars, 開始索引, 具體長度);
    System.out.print(s);
}

一次讀取一行資料（不包括換行符）：

String line = null;
while ((line = br.readLine()) != null) {
    System.out.print(line);
}

字元輸出流

抽象父類: Writer

實現子類:

OutputStreamWriter

建立物件的方式：

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("路徑"));

寫資料的方式：
- 一次寫一個字元。
```
osw.write(i);
```
- 一次寫一個字元陣列。
```
char[] chars = {'a', 'b', 'c'};
osw.write(chars);
```
- 一次寫一個字元陣列的一部分。
```
char[] chars = {'a', 'b', 'c'};
osw.write(chars, 1, 2);
```
- 一次寫一個字串。
```
osw.write("example");
```
- 一次寫一個字串的一部分。
```
osw.write("example", 1, 4);
```

FileWriter

建立物件的方式：

FileWriter fw = new FileWriter("路徑");

寫資料的方式：
- 一次寫一個字元。
```
fw.write(i);
```
- 一次寫一個字元陣列。
```
char[] chars = {'a', 'b', 'c'};
fw.write(chars);
```
- 一次寫一個字元陣列的一部分。
```
char[] chars = {'a', 'b', 'c'};
fw.write(chars, 1, 2);
```
- 一次寫一個字串。
```
fw.write("example");
```
- 一次寫一個字串的一部分。
```
fw.write("example", 1, 4);
```

BufferedWriter

建立物件的方式：

方式1：

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("路徑")));

方式2（簡化版）：

BufferedWriter bw = new BufferedWriter(new FileWriter("路徑"));

寫資料的方式：
- 一次寫一個字元：
```
bw.write(i);
```
- 一次寫一個字元陣列：
```
char[] chars = {'a', 'b', 'c'};
bw.write(chars);
```
- 一次寫一個字元陣列的一部分：
```
char[] chars = {'a', 'b', 'c'};
bw.write(chars, 1, 2);
```
- 一次寫一個字串：
```
bw.write("example");
```
- 一次寫一個字串的一部分：
```
bw.write("example", 1, 4);
```
- 特殊功能：自動生成換行符：
```
bw.newLine();
```

檔案的讀寫複製

位元組流

普通位元組輸入輸出流：一次讀寫一個位元組。

    FileInputStream inputPath = new FileInputStream("inputpath");
    FileOutputStream outputPath = new FileOutputStream("outpath");

    int i = 0;
    while ((i = inputPath.read()) != -1) {
        outputPath.write((char) i);
     }
    inputPath.close();
    outputPath.close();

帶緩衝的位元組輸入輸出流：一次讀寫一個位元組。

    BufferedInputStream inputpath = new BufferedInputStream(new FileInputStream("inputpath"));
    BufferedOutputStream outputpath = new BufferedOutputStream(new FileOutputStream("outpath"));

    int i = 0;

    while ((i = inputpath.read()) != -1) {
        outputpath.write((char) i);
        outputpath.flush;
     }

    inputpath.close();
    outputpath.close();

普通位元組輸入輸出流：一次讀寫一個位元組陣列。

    FileInputStream inputPath = new FileInputStream("inputpath");
    FileOutputStream outputPath = new FileOutputStream("outpath");

    byte[] bytes = new byte[1024];
    int length = 0;
    while ((length = inputPath.read(bytes)) != -1) {
        outputPath.write(bytes, 0, length);
        outputPath.flush();
     }
    inputPath.close();
    outputPath.close();

帶緩衝的位元組輸入輸出流：一次讀寫一個位元組陣列（此方式的效率最高）。

    BufferedInputStream inputpath = new BufferedInputStream(new FileInputStream("inputpath"));
    BufferedOutputStream outputpath = new BufferedOutputStream(new FileOutputStream("outpath"));

    byte[] bytes = new byte[1024];
    int length = 0;
    while ((length = inputpath.read(bytes)) != -1) {
        outputpath.write(bytes, 0, length);
        outputpath.flush();
    }

    inputpath.close();
    outputpath.close();

字元流

普通字元輸入輸出流：一次讀寫一個字元。

    InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("inputpath"));
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("outputpath"));

    int i = 0;
    while ((i = inputStreamReader.read()) != -1) {
        outputStreamWriter.write(i);
        outputStreamWriter.flush();
    }

    inputStreamReader.close();
    outputStreamWriter.close();

普通字元輸入輸出流：一次讀寫一個字元陣列。

    InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("inputpath"));
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("outputpath"));

    char[] chars = new char[1024];
    int length = 0;
    while ((length = inputStreamReader.read(chars)) != -1) {
        outputStreamWriter.write(chars,0,length);
        outputStreamWriter.flush();
    }

    inputStreamReader.close();
    outputStreamWriter.close();

簡化寫法字元輸入輸出流：一次讀寫一個字元。

    FileReader fileReader = new FileReader("inputpath");
    FileWriter fileWriter = new FileWriter("outputpath");

    int i = 0;
    while ((i = fileReader.read()) != -1) {
        fileWriter.write(i);
        fileWriter.flush();
    }

    fileWriter.close();
    fileReader.close();

簡化寫法字元輸入輸出流：一次讀寫一個字元陣列。

    FileReader fileReader = new FileReader("inputpath");
    FileWriter fileWriter = new FileWriter("src/com/shujia/data/b.txt");

    char[] chars = new char[1024];
    int length = 0;
    while ((length = fileReader.read(chars)) != -1) {
        fileWriter.write(chars,0,length);
        fileWriter.flush();
    }

    fileWriter.close();
    fileReader.close();

字元緩衝輸入輸出流：一次讀寫一個字元。

    BufferedReader bufferedReader = new BufferedReader(new FileReader("inputpath"));
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("outpath"));

    int i = 0;
    while ((i = bufferedReader.read()) != -1) {
         bufferedWriter.write(i);
         bufferedWriter.flush();
    }

    bufferedWriter.close();
    bufferedReader.close();

字元緩衝輸入輸出流：一次讀寫一個字元陣列。

    BufferedReader bufferedReader = new BufferedReader(new FileReader("inputpath"));
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("outpath"));

    char[] chars = new char[1024];
    int length = 0;
    while ((length = bufferedReader.read(chars)) != -1) {
    bufferedWriter.write(chars,0,length);
    bufferedWriter.flush();
    }

    bufferedWriter.close();
    bufferedReader.close();

字元緩衝輸入輸出流：一次讀寫一行資料。

    BufferedReader bufferedReader = new BufferedReader(new FileReader("inputpath"));
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("outpath"));

    String i = null;
    while ((i = bufferedReader.readLine()) != null) {
        bufferedWriter.write(i);
        bufferedWriter.newLine();
        bufferedWriter.flush();
     }

    bufferedWriter.close();
    bufferedReader.close();

JavaSE基礎知識分享(十五)
2024-08-25
Java
JavaSE基礎知識分享(六)
2024-08-14
Java
JavaSE基礎知識分享(七)
2024-08-15
Java
JavaSE基礎知識分享(九)
2024-08-18
Java
JavaSE基礎知識分享(三)
2024-08-05
Java
JavaSE基礎知識分享(十二)
2024-08-21
Java
JavaSE基礎知識分享(十四)
2024-08-23
Java
JavaSE基礎知識分享(八)
2024-08-16
Java
JavaSE基礎知識分享(十一)
2024-08-20
Java
JavaSE基礎知識分享(五)
2024-08-12
Java
JavaSE基礎知識分享(四)
2024-08-09
Java
JavaSE基礎知識分享(一)
2024-07-28
Java
JavaSE基礎知識分享(二)
2024-07-30
Java
JavaSE基礎知識分享(二)相關練習題
2024-08-01
Java
JavaSE基礎知識學習—–多型
2019-02-25
Java多型
JavaSE基礎學習知識整理大全
2018-08-30
Java
JavaSE基礎 (全網最全知識點)
2023-02-27
Java
Python基礎知識分享
2018-03-12
Python
GO基礎知識分享
2021-03-31
Go
JavaSE基礎知識學習—–抽象類和介面
2019-02-18
Java抽象
zookeeper基礎知識分享(一)
2024-11-12
HBase基礎知識分享(二)
2024-11-14
hadoop基礎知識分享(二)
2024-11-06
Hadoop
MySQL基礎知識分享(二)
2024-08-04
MySql
hadoop基礎知識分享(一)
2024-09-08
Hadoop
MySQL基礎知識分享(一)
2024-07-26
MySql
GO基礎知識分享2
2021-03-31
Go
JavaSE基礎程式設計十題
2024-07-29
Java程式設計
sql入門基礎知識分享
2019-04-01
SQL
【知識分享】伺服器基礎知識【初學者必看】
2023-02-24
伺服器
二、javase基礎知識總結（從檔案 I/O開始)
2021-09-09
Java
網站組成部分基礎知識分享
2019-04-01
網站
軟體效能測試基礎知識分享
2023-02-08
JavaSE小知識（二）
2020-11-20
Java
基礎知識
2018-03-29
使用AngularJS學習MVC的基礎知識分享
2019-04-01
AngularJSMVC
Python教程分享之Python基礎知識點梳理
2021-05-07
Python
Envoy基礎知識
2018-10-29

JavaSE基礎知識分享(十)

寫在前面

Java 檔案與流操作

File 類

構造方法

成員方法

建立功能

刪除功能

重新命名功能

判斷功能

基本獲取功能

高階獲取功能

檔名稱過濾器

位元組流

位元組輸入流

位元組輸出流

字元流

字元輸入流

字元輸出流

檔案的讀寫複製

位元組流

字元流

相關文章