JavaSE學習筆記(14)---File類和IO流(位元組流和字元流)

来源:https://www.cnblogs.com/xjtu-lyh/archive/2020/02/14/12310117.html

JavaSE學習筆記(14) File類和IO流(位元組流和字元流) File類 概述 類是文件和目錄路徑名的抽象表示,主要用於文件和目錄的創建、查找和刪除等操作。 構造方法 :通過將給定的 路徑名字元串 轉換為抽象路徑名來創建新的 File實例。 :從 父路徑名字元串和子路徑名字元串 創建新的 Fi ...


JavaSE學習筆記(14)---File類和IO流(位元組流和字元流)

File類

概述

java.io.File 類是文件和目錄路徑名的抽象表示,主要用於文件和目錄的創建、查找和刪除等操作。

構造方法

  • public File(String pathname) :通過將給定的路徑名字元串轉換為抽象路徑名來創建新的 File實例。
  • public File(String parent, String child) :從父路徑名字元串和子路徑名字元串創建新的 File實例。
  • public File(File parent, String child) :從父抽象路徑名和子路徑名字元串創建新的 File實例。

  • 構造舉例,代碼如下:

// 文件路徑名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname); 

// 文件路徑名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2); 

// 通過父路徑和子路徑字元串
 String parent = "d:\\aaa";
 String child = "bbb.txt";
 File file3 = new File(parent, child);

// 通過父級File對象和子路徑字元串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);

小貼士:

  1. 一個File對象代表硬碟中實際存在的一個文件或者目錄。
  2. 無論該路徑下是否存在文件或者目錄,都不影響File對象的創建。

常用方法

獲取功能的方法

  • public String getAbsolutePath() :返回此File的絕對路徑名字元串。

  • public String getPath() :將此File轉換為路徑名字元串。

  • public String getName() :返回由此File表示的文件或目錄的名稱。

  • public long length() :返回由此File表示的文件的長度。

    方法演示,代碼如下:

    public class FileGet {
        public static void main(String[] args) {
            File f = new File("d:/aaa/bbb.java");     
            System.out.println("文件絕對路徑:"+f.getAbsolutePath());
            System.out.println("文件構造路徑:"+f.getPath());
            System.out.println("文件名稱:"+f.getName());
            System.out.println("文件長度:"+f.length()+"位元組");
    
            File f2 = new File("d:/aaa");     
            System.out.println("目錄絕對路徑:"+f2.getAbsolutePath());
            System.out.println("目錄構造路徑:"+f2.getPath());
            System.out.println("目錄名稱:"+f2.getName());
            System.out.println("目錄長度:"+f2.length());
        }
    }
    輸出結果:
    文件絕對路徑:d:\aaa\bbb.java
    文件構造路徑:d:\aaa\bbb.java
    文件名稱:bbb.java
    文件長度:636位元組
    
    目錄絕對路徑:d:\aaa
    目錄構造路徑:d:\aaa
    目錄名稱:aaa
    目錄長度:4096

API中說明:length(),表示文件的長度。但是File對象表示目錄,則返回值未指定。

絕對路徑和相對路徑

  • 絕對路徑:從盤符開始的路徑,這是一個完整的路徑。
  • 相對路徑:相對於項目目錄的路徑,這是一個便捷的路徑,開發中經常使用。
public class FilePath {
    public static void main(String[] args) {
        // D盤下的bbb.java文件
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
        
        // 項目下的bbb.java文件
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
    }
}
輸出結果:
D:\bbb.java
D:\idea_project_test4\bbb.java

判斷功能的方法

  • public boolean exists() :此File表示的文件或目錄是否實際存在。
  • public boolean isDirectory() :此File表示的是否為目錄。
  • public boolean isFile() :此File表示的是否為文件。

方法演示,代碼如下:

public class FileIs {
    public static void main(String[] args) {
        File f = new File("d:\\aaa\\bbb.java");
        File f2 = new File("d:\\aaa");
        // 判斷是否存在
        System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
        System.out.println("d:\\aaa 是否存在:"+f2.exists());
        // 判斷是文件還是目錄
        System.out.println("d:\\aaa 文件?:"+f2.isFile());
        System.out.println("d:\\aaa 目錄?:"+f2.isDirectory());
    }
}
輸出結果:
d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d:\aaa 文件?:false
d:\aaa 目錄?:true

創建刪除功能的方法

  • public boolean createNewFile() :當且僅當具有該名稱的文件尚不存在時,創建一個新的空文件。
  • public boolean delete() :刪除由此File表示的文件或目錄。
  • public boolean mkdir() :創建由此File表示的目錄。
  • public boolean mkdirs() :創建由此File表示的目錄,包括任何必需但不存在的父目錄。

方法演示,代碼如下:

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {
        // 文件的創建
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists()); // false
        System.out.println("是否創建:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true
        
        // 目錄的創建
        File f2= new File("newDir");    
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否創建:"+f2.mkdir()); // true
        System.out.println("是否存在:"+f2.exists());// true

        // 創建多級目錄
        File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true
      
        // 文件的刪除
        System.out.println(f.delete());// true
      
        // 目錄的刪除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false
    }
}

API中說明:delete方法,如果此File表示目錄,則目錄必須為空才能刪除。

目錄的遍歷

  • public String[] list() :返回一個String數組,表示該File目錄中的所有子文件或目錄。

  • public File[] listFiles() :返回一個File數組,表示該File目錄中的所有的子文件或目錄。

public class FileFor {
    public static void main(String[] args) {
        File dir = new File("d:\\java_code");
      
        //獲取當前目錄下的文件以及文件夾的名稱。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //獲取當前目錄下的文件以及文件夾對象,只要拿到了文件對象,那麼就可以獲取更多信息
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

小貼士:

調用listFiles方法的File對象,表示的必須是實際存在的目錄,否則返回null,無法進行遍歷。

IO概述

什麼是IO

生活中,你肯定經歷過這樣的場景。當你編輯一個文本文件,忘記了ctrl+s ,可能文件就白白編輯了。當你電腦上插入一個U盤,可以把一個視頻,拷貝到你的電腦硬碟里。那麼數據都是在哪些設備上的呢?鍵盤、記憶體、硬碟、外接設備等等。

我們把這種數據的傳輸,可以看做是一種數據的流動,按照流動的方向,以記憶體為基準,分為輸入input輸出output ,即流向記憶體是輸入流,流出記憶體的輸出流。

Java中I/O操作主要是指使用java.io包下的內容,進行輸入、輸出操作。輸入也叫做讀取數據,輸出也叫做作寫出數據。

IO的分類

根據數據的流向分為:輸入流輸出流

  • 輸入流 :把數據從其他設備上讀取到記憶體中的流。
  • 輸出流 :把數據從記憶體 中寫出到其他設備上的流。

格局數據的類型分為:位元組流字元流

  • 位元組流 :以位元組為單位,讀寫數據的流。
  • 字元流 :以字元為單位,讀寫數據的流。

IO的流向說明

  • 輸入:硬碟到記憶體
  • 輸出:記憶體到硬碟

頂級父類們

輸入流 輸出流
位元組流 位元組輸入流
InputStream
位元組輸出流
OutputStream
字元流 字元輸入流
Reader
字元輸出流
Writer

位元組流

一切皆為位元組

一切文件數據(文本、圖片、視頻等)在存儲時,都是以二進位數字的形式保存,都一個一個的位元組,那麼傳輸時一樣如此。所以,位元組流可以傳輸任意文件數據。在操作流的時候,我們要時刻明確,無論使用什麼樣的流對象,底層傳輸的始終為二進位數據。

位元組輸出流【OutputStream】

java.io.OutputStream抽象類是表示位元組輸出流的所有類的超類,將指定的位元組信息寫出到目的地。它定義了位元組輸出流的基本共性功能方法。

  • public void close() :關閉此輸出流並釋放與此流相關聯的任何系統資源。
  • public void flush() :刷新此輸出流並強制任何緩衝的輸出位元組被寫出。
  • public void write(byte[] b):將 b.length位元組從指定的位元組數組寫入此輸出流。
  • public void write(byte[] b, int off, int len) :從指定的位元組數組寫入 len位元組,從偏移量 off開始輸出到此輸出流。
  • public abstract void write(int b) :將指定的位元組輸出流。

小貼士:

close方法,當完成流的操作時,必須調用此方法,釋放系統資源。

FileOutputStream類

OutputStream有很多子類,我們從最簡單的一個子類開始。

java.io.FileOutputStream類是文件輸出流,用於將數據寫出到文件。

構造方法

  • public FileOutputStream(File file):創建文件輸出流以寫入由指定的 File對象表示的文件。
  • public FileOutputStream(String name): 創建文件輸出流以指定的名稱寫入文件。

當你創建一個流對象時,必須傳入一個文件路徑。該路徑下,如果沒有這個文件,會創建該文件。如果有這個文件,會清空這個文件的數據。

  • 構造舉例,代碼如下:
public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
        // 使用File對象創建流對象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名稱創建流對象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

寫出位元組數據

  1. 寫出位元組write(int b) 方法,每次可以寫出一個位元組數據,代碼使用演示:
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
        // 寫出數據
        fos.write(97); // 寫出第1個位元組
        fos.write(98); // 寫出第2個位元組
        fos.write(99); // 寫出第3個位元組
        // 關閉資源
        fos.close();
    }
}
輸出結果:
abc

小貼士:

  1. 雖然參數為int類型四個位元組,但是只會保留一個位元組的信息寫出。
  2. 流操作完畢後,必須釋放系統資源,調用close方法,千萬記得。
  1. 寫出位元組數組write(byte[] b),每次可以寫出數組中的數據,代碼使用演示:
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
        // 字元串轉換為位元組數組
        byte[] b = "一二三四五六".getBytes();
        // 寫出位元組數組數據
        fos.write(b);
        // 關閉資源
        fos.close();
    }
}
輸出結果:
一二三四五六
  1. 寫出指定長度位元組數組write(byte[] b, int off, int len) ,每次寫出從off索引開始,len個位元組,代碼使用演示:
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
        // 字元串轉換為位元組數組
        byte[] b = "abcde".getBytes();
        // 寫出從索引2開始,2個位元組。索引2是c,兩個位元組,也就是cd。
        fos.write(b,2,2);
        // 關閉資源
        fos.close();
    }
}
輸出結果:
cd

數據追加續寫

經過以上的演示,每次程式運行,創建輸出流對象,都會清空目標文件中的數據。如何保留目標文件中數據,還能繼續添加新數據呢?

  • public FileOutputStream(File file, boolean append): 創建文件輸出流以寫入由指定的 File對象表示的文件。
  • public FileOutputStream(String name, boolean append): 創建文件輸出流以指定的名稱寫入文件。

這兩個構造方法,參數中都需要傳入一個boolean類型的值,true 表示追加數據,false 表示清空原有數據。這樣創建的輸出流對象,就可以指定是否追加續寫了,代碼使用演示:

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileOutputStream fos = new FileOutputStream("fos.txt",true);     
        // 字元串轉換為位元組數組
        byte[] b = "abcde".getBytes();
        // 寫出從索引2開始,2個位元組。索引2是c,兩個位元組,也就是cd。
        fos.write(b);
        // 關閉資源
        fos.close();
    }
}
文件操作前:cd
文件操作後:cdabcde

寫出換行

Windows系統里,換行符號是\r\n

以指定是否追加續寫了,代碼使用演示:

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
        // 定義位元組數組
        byte[] words = {97,98,99,100,101};
        // 遍曆數組
        for (int i = 0; i < words.length; i++) {
            // 寫出一個位元組
            fos.write(words[i]);
            // 寫出一個換行, 換行符號轉成數組寫出
            fos.write("\r\n".getBytes());
        }
        // 關閉資源
        fos.close();
    }
}

輸出結果:
a
b
c
d
e
  • 回車符\r和換行符\n
    • 回車符:回到一行的開頭(return)。
    • 換行符:下一行(newline)。
  • 系統中的換行:
    • Windows系統里,每行結尾是 回車+換行 ,即\r\n
    • Unix系統里,每行結尾只有 換行 ,即\n
    • Mac系統里,每行結尾是 回車 ,即\r。從 Mac OS X開始與Linux統一。

位元組輸入流【InputStream】

java.io.InputStream抽象類是表示位元組輸入流的所有類的超類,可以讀取位元組信息到記憶體中。它定義了位元組輸入流的基本共性功能方法。

  • public void close() :關閉此輸入流並釋放與此流相關聯的任何系統資源。
  • public abstract int read(): 從輸入流讀取數據的下一個位元組。
  • public int read(byte[] b): 從輸入流中讀取一些位元組數,並將它們存儲到位元組數組 b中 。

小貼士:

close方法,當完成流的操作時,必須調用此方法,釋放系統資源。

FileInputStream類

java.io.FileInputStream類是文件輸入流,從文件中讀取位元組。

構造方法

  • FileInputStream(File file): 通過打開與實際文件的連接來創建一個 FileInputStream ,該文件由文件系統中的 File對象 file命名。
  • FileInputStream(String name): 通過打開與實際文件的連接來創建一個 FileInputStream ,該文件由文件系統中的路徑名 name命名。

當你創建一個流對象時,必須傳入一個文件路徑。該路徑下,如果沒有該文件,會拋出FileNotFoundException

  • 構造舉例,代碼如下:
public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
        // 使用File對象創建流對象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用文件名稱創建流對象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

讀取位元組數據

  1. 讀取位元組read方法,每次可以讀取一個位元組的數據,提升為int類型,讀取到文件末尾,返回-1,代碼使用演示:
public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用文件名稱創建流對象
        FileInputStream fis = new FileInputStream("read.txt");
        // 讀取數據,返回一個位元組
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        // 讀取到末尾,返回-1
        read = fis.read();
        System.out.println( read);
        // 關閉資源
        fis.close();
    }
}
輸出結果:
a
b
c
d
e
-1

迴圈改進讀取方式,代碼使用演示:

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用文件名稱創建流對象
        FileInputStream fis = new FileInputStream("read.txt");
        // 定義變數,保存數據
        int b ;
        // 迴圈讀取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
        // 關閉資源
        fis.close();
    }
}
輸出結果:
a
b
c
d
e

小貼士:

  1. 雖然讀取了一個位元組,但是會自動提升為int類型。
  2. 流操作完畢後,必須釋放系統資源,調用close方法,千萬記得。
  1. 使用位元組數組讀取read(byte[] b),每次讀取b的長度個位元組到數組中,返回讀取到的有效位元組個數,讀取到末尾時,返回-1 ,代碼使用演示:
public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用文件名稱創建流對象.
        FileInputStream fis = new FileInputStream("read.txt"); // 文件中為abcde
        // 定義變數,作為有效個數
        int len ;
        // 定義位元組數組,作為裝位元組數據的容器   
        byte[] b = new byte[2];
        // 迴圈讀取
        while (( len= fis.read(b))!=-1) {
            // 每次讀取後,把數組變成字元串列印
            System.out.println(new String(b));
        }
        // 關閉資源
        fis.close();
    }
}

輸出結果:
ab
cd
ed

錯誤數據d,是由於最後一次讀取時,只讀取一個位元組e,數組中,上次讀取的數據沒有被完全替換,所以要通過len ,獲取有效的位元組,代碼使用演示:

public class FISRead {
    public static void main(String[] args) throws IOException{
        // 使用文件名稱創建流對象.
        FileInputStream fis = new FileInputStream("read.txt"); // 文件中為abcde
        // 定義變數,作為有效個數
        int len ;
        // 定義位元組數組,作為裝位元組數據的容器   
        byte[] b = new byte[2];
        // 迴圈讀取
        while (( len= fis.read(b))!=-1) {
            // 每次讀取後,把數組的有效位元組部分,變成字元串列印
            System.out.println(new String(b,0,len));//  len 每次讀取的有效位元組個數
        }
        // 關閉資源
        fis.close();
    }
}

輸出結果:
ab
cd
e

小貼士:

使用數組讀取,每次讀取多個位元組,減少了系統間的IO操作次數,從而提高了讀寫的效率,建議開發中使用。

位元組流練習:圖片複製

複製原理圖解

案例實現

複製圖片文件,代碼使用演示:

public class Copy {
    public static void main(String[] args) throws IOException {
        // 1.創建流對象
        // 1.1 指定數據源
        FileInputStream fis = new FileInputStream("D:\\test.jpg");
        // 1.2 指定目的地
        FileOutputStream fos = new FileOutputStream("test_copy.jpg");

        // 2.讀寫數據
        // 2.1 定義數組
        byte[] b = new byte[1024];
        // 2.2 定義長度
        int len;
        // 2.3 迴圈讀取
        while ((len = fis.read(b))!=-1) {
            // 2.4 寫出數據
            fos.write(b, 0 , len);
        }

        // 3.關閉資源
        fos.close();
        fis.close();
    }
}

小貼士:

流的關閉原則:先開後關,後開先關。

字元流

當使用位元組流讀取文本文件時,可能會有一個小問題。就是遇到中文字元時,可能不會顯示完整的字元,那是因為一個中文字元可能占用多個位元組存儲。所以Java提供一些字元流類,以字元為單位讀寫數據,專門用於處理文本文件。

字元輸入流【Reader】

java.io.Reader抽象類是表示用於讀取字元流的所有類的超類,可以讀取字元信息到記憶體中。它定義了字元輸入流的基本共性功能方法。

  • public void close() :關閉此流並釋放與此流相關聯的任何系統資源。
  • public int read(): 從輸入流讀取一個字元。
  • public int read(char[] cbuf): 從輸入流中讀取一些字元,並將它們存儲到字元數組 cbuf中 。

FileReader類

java.io.FileReader類是讀取字元文件的便利類。構造時使用系統預設的字元編碼和預設位元組緩衝區。

小貼士:

  1. 字元編碼:位元組與字元的對應規則。Windows系統的中文編碼預設是GBK編碼表。

    idea中UTF-8

  2. 位元組緩衝區:一個位元組數組,用來臨時存儲位元組數據。

構造方法

  • FileReader(File file): 創建一個新的 FileReader ,給定要讀取的File對象。
  • FileReader(String fileName): 創建一個新的 FileReader ,給定要讀取的文件的名稱。

當你創建一個流對象時,必須傳入一個文件路徑。類似於FileInputStream 。

  • 構造舉例,代碼如下:
public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
        // 使用File對象創建流對象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
      
        // 使用文件名稱創建流對象
        FileReader fr = new FileReader("b.txt");
    }
}

讀取字元數據

read.txt里是“一二三四五”

  1. 讀取字元read方法,每次可以讀取一個字元的數據,提升為int類型,讀取到文件末尾,返回-1,迴圈讀取,代碼使用演示:
public class FRRead {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileReader fr = new FileReader("read.txt");
        // 定義變數,保存數據
        int b ;
        // 迴圈讀取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
        // 關閉資源
        fr.close();
    }
}
輸出結果:
一
二
三
四
五

小貼士:雖然讀取了一個字元,但是會自動提升為int類型。

  1. 使用字元數組讀取read(char[] cbuf),每次讀取b的長度個字元到數組中,返回讀取到的有效字元個數,讀取到末尾時,返回-1 ,代碼使用演示:
public class FRRead {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileReader fr = new FileReader("read.txt");
        // 定義變數,保存有效字元個數
        int len ;
        // 定義字元數組,作為裝字元數據的容器
         char[] cbuf = new char[2];
        // 迴圈讀取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
        // 關閉資源
        fr.close();
    }
}
輸出結果:
一二
三四
五四

獲取有效的字元改進,代碼使用演示:

public class FISRead {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileReader fr = new FileReader("read.txt");
        // 定義變數,保存有效字元個數
        int len ;
        // 定義字元數組,作為裝字元數據的容器
        char[] cbuf = new char[2];
        // 迴圈讀取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
        // 關閉資源
        fr.close();
    }
}

輸出結果:
一二
三四
五

字元輸出流【Writer】

java.io.Writer抽象類是表示用於寫出字元流的所有類的超類,將指定的字元信息寫出到目的地。它定義了位元組輸出流的基本共性功能方法。

  • void write(int c) 寫入單個字元。
  • void write(char[] cbuf)寫入字元數組。
  • abstract void write(char[] cbuf, int off, int len)寫入字元數組的某一部分,off數組的開始索引,len寫的字元個數。
  • void write(String str)寫入字元串。
  • void write(String str, int off, int len) 寫入字元串的某一部分,off字元串的開始索引,len寫的字元個數。
  • void flush()刷新該流的緩衝。
  • void close() 關閉此流,但要先刷新它。

FileWriter類

java.io.FileWriter類是寫出字元到文件的便利類。構造時使用系統預設的字元編碼和預設位元組緩衝區。

構造方法

  • FileWriter(File file): 創建一個新的 FileWriter,給定要讀取的File對象。
  • FileWriter(String fileName): 創建一個新的 FileWriter,給定要讀取的文件的名稱。

當你創建一個流對象時,必須傳入一個文件路徑,類似於FileOutputStream。

  • 構造舉例,代碼如下:
public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
        // 使用File對象創建流對象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用文件名稱創建流對象
        FileWriter fw = new FileWriter("b.txt");
    }
}

基本寫出數據

寫出字元write(int b) 方法,每次可以寫出一個字元數據,代碼使用演示:

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileWriter fw = new FileWriter("fw.txt");     
        // 寫出數據
        fw.write(97); // 寫出第1個字元
        fw.write('b'); // 寫出第2個字元
        fw.write('C'); // 寫出第3個字元
        fw.write(30000); // 寫出第4個字元,中文編碼表中30000對應一個漢字。
      
        /*
        【註意】關閉資源時,與FileOutputStream不同。
         如果不關閉,數據只是保存到緩衝區,並未保存到文件。
        */
        // fw.close();
    }
}
輸出結果:
abC田

小貼士:

  1. 雖然參數為int類型四個位元組,但是只會保留一個字元的信息寫出。
  2. 未調用close方法,數據只是保存到了緩衝區,並未寫出到文件中。

關閉和刷新

因為內置緩衝區的原因,如果不關閉輸出流,無法寫出字元到文件中。但是關閉的流對象,是無法繼續寫出數據的。如果我們既想寫出數據,又想繼續使用流,就需要flush 方法了。

  • flush :刷新緩衝區,流對象可以繼續使用。
  • close:先刷新緩衝區,然後通知系統釋放資源。流對象不可以再被使用了。

代碼使用演示:

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileWriter fw = new FileWriter("fw.txt");
        // 寫出數據,通過flush
        fw.write('刷'); // 寫出第1個字元
        fw.flush();
        fw.write('新'); // 繼續寫出第2個字元,寫出成功
        fw.flush();
      
        // 寫出數據,通過close
        fw.write('關'); // 寫出第1個字元
        fw.close();
        fw.write('閉'); // 繼續寫出第2個字元,【報錯】java.io.IOException: Stream closed
        fw.close();
    }
}

小貼士:即便是flush方法寫出了數據,操作的最後還是要調用close方法,釋放系統資源。

寫出其他數據

  1. 寫出字元數組write(char[] cbuf)write(char[] cbuf, int off, int len) ,每次可以寫出字元數組中的數據,用法類似FileOutputStream,代碼使用演示:
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileWriter fw = new FileWriter("fw.txt");     
        // 字元串轉換為位元組數組
        char[] chars = "黑馬程式員".toCharArray();
      
        // 寫出字元數組
        fw.write(chars); // 黑馬程式員
        
        // 寫出從索引2開始,2個位元組。索引2是'程',兩個位元組,也就是'程式'。
        fw.write(b,2,2); // 程式
      
        // 關閉資源
        fos.close();
    }
}
  1. 寫出字元串write(String str)write(String str, int off, int len) ,每次可以寫出字元串中的數據,更為方便,代碼使用演示:
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象
        FileWriter fw = new FileWriter("fw.txt");     
        // 字元串
        String msg = "黑馬程式員";
      
        // 寫出字元數組
        fw.write(msg); //黑馬程式員
      
        // 寫出從索引2開始,2個位元組。索引2是'程',兩個位元組,也就是'程式'。
        fw.write(msg,2,2);  // 程式
        
        // 關閉資源
        fos.close();
    }
}
  1. 續寫和換行:操作類似於FileOutputStream。
public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名稱創建流對象,可以續寫數據
        FileWriter fw = new FileWriter("fw.txt",true);     
        // 寫出字元串
        fw.write("黑馬");
        // 寫出換行
        fw.write("\r\n");
        // 寫出字元串
        fw.write("程式員");
        // 關閉資源
        fw.close();
    }
}
輸出結果:
黑馬
程式員

小貼士:字元流,只能操作文本文件,不能操作圖片,視頻等非文本文件。

當我們單純讀或者寫文本文件時 使用字元流 其他情況使用位元組流

IO異常的處理

JDK7前處理

之前的入門練習,我們一直把異常拋出,而實際開發中並不能這樣處理,建議使用try...catch...finally 代碼塊,處理異常部分,代碼使用演示:

public class HandleException1 {
    public static void main(String[] args) {
        // 聲明變數
        FileWriter fw = null;
        try {
            //創建流對象
            fw = new FileWriter("fw.txt");
            // 寫出數據
            fw.write("黑馬程式員"); //黑馬程式員
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK7的處理

還可以使用JDK7優化後的try-with-resource 語句,該語句確保了每個資源在語句結束時關閉。所謂的資源(resource)是指在程式完成後,必須關閉的對象。

格式:

try (創建流對象語句,如果多個,使用';'隔開) {
    // 讀寫數據
} catch (IOException e) {
    e.printStackTrace();
}

代碼使用演示:

public class HandleException2 {
    public static void main(String[] args) {
        // 創建流對象
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 寫出數據
            fw.write("黑馬程式員"); //黑馬程式員
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9的改進

JDK9中try-with-resource 的改進,對於引入對象的方式,支持的更加簡潔。被引入的對象,同樣可以自動關閉,無需手動close,我們來瞭解一下格式。

改進前格式:

// 被final修飾的對象
final Resource resource1 = new Resource("resource1");
// 普通對象
Resource resource2 = new Resource("resource2");
// 引入方式:創建新的變數保存
try (Resource r1 = resource1;
     Resource r2 = resource2) {
     // 使用對象
}

改進後格式:

// 被final修飾的對象
final Resource resource1 = new Resource("resource1");
// 普通對象
Resource resource2 = new Resource("resource2");

// 引入方式:直接引入
try (resource1; resource2) {
     // 使用對象
}

改進後,代碼使用演示:

public class TryDemo {
    public static void main(String[] args) throws IOException {
        // 創建流對象
        final  FileReader fr  = new FileReader("in.txt");
        FileWriter fw = new FileWriter("out.txt");
        // 引入到try中
        try (fr; fw) {
            // 定義變數
            int b;
            // 讀取數據
            while ((b = fr.read())!=-1) {
                // 寫出數據
                fw.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

屬性集

概述

java.util.Properties 繼承於Hashtable ,來表示一個持久的屬性集。它使用鍵值結構存儲數據,每個鍵及其對應值都是一個字元串。該類也被許多Java類使用,比如獲取系統屬性時,System.getProperties 方法就是返回一個Properties對象。

Properties類

構造方法

  • public Properties() :創建一個空的屬性列表。

基本的存儲方法

  • public Object setProperty(String key, String value) : 保存一對屬性。
  • public String getProperty(String key) :使用此屬性列表中指定的鍵搜索屬性值。
  • public Set<String> stringPropertyNames() :所有鍵的名稱的集合。
public class ProDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 創建屬性集對象
        Properties properties = new Properties();
        // 添加鍵值對元素
        properties.setProperty("filename", "a.txt");
        properties.setProperty("length", "209385038");
        properties.setProperty("location", "D:\\a.txt");
        // 列印屬性集對象
        System.out.println(properties);
        // 通過鍵,獲取屬性值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("length"));
        System.out.println(properties.getProperty("location"));

        // 遍歷屬性集,獲取所有鍵的集合
        Set<String> strings = properties.stringPropertyNames();
        // 列印鍵值對
        for (String key : strings ) {
            System.out.println(key+" -- "+properties.getProperty(key));
        }
    }
}
輸出結果:
{filename=a.txt, length=209385038, location=D:\a.txt}
a.txt
209385038
D:\a.txt
filename -- a.txt
length -- 209385038
location -- D:\a.txt

與流相關的方法

  • public void load(InputStream inStream): 從位元組輸入流中讀取鍵值對。

參數中使用了位元組輸入流,通過流對象,可以關聯到某文件上,這樣就能夠載入文本中的數據了。文本數據格式:

filename=a.txt
length=209385038
location=D:\a.txt

載入代碼演示:

public class ProDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        // 創建屬性集對象
        Properties pro = new Properties();
        // 載入文本中信息到屬性集
        pro.load(new FileInputStream("read.txt"));
        // 遍歷集合併列印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings ) {
            System.out.println(key+" -- "+pro.getProperty(key));
        }
     }
}
輸出結果:
filename -- a.txt
length -- 209385038
location -- D:\a.txt

小貼士:文本中的數據,必須是鍵值對形式,可以使用空格、等號、冒號等符號分隔。


您的分享是我們最大的動力!

更多相關文章
  • 一、Overview angular 入坑記錄的筆記第一篇,完成開發環境的搭建,以及如何通過 angular cli 來創建第一個 angular 應用。入坑一個多星期,通過學習官方文檔以及手摸手的按教程敲官方的快速上手項目,很像後端,嗯,完美的契合了我這種後端開發人員。 對應官方文檔地址: 搭建本 ...
  • [1]介紹 [2]優勢 [3]安裝 [4]使用 [5]cask [6]逸事 ...
  • 簡單工廠模式 為什麼要有工程模式? 因為在有很多對象需要集中集中操作的時候,可以減少代碼的復用和提高代碼的靈活性,具體參考下例。 什麼是工廠模式? 1、什麼是工廠? 一個專門來創建實例的類叫做工廠,下麵是一個簡單的例子。 工廠模式的好處有哪些? 提高代碼服用性和靈活性,工廠模式解決了對象創建問題。 ...
  • 1、原型模式介紹 2、深拷貝 3、淺拷貝 4、弊端分析 5、示例代碼演示 6、改進方案 ...
  • 一、單向鏈表 1.單向鏈表:每個元素都稱為節點(Entry),每個節點都由兩部分組成 2.單向鏈表的註意點: (1)單向鏈表每一個節點在記憶體中存儲上在空間位置上是無規律的; (2)為什麼單向鏈表的查詢效率變低​?因為單向鏈表中的每個元素在空間的存儲位置上沒有規律,也沒有順序,那麼在查找某個元素的時候 ...
  • 【基礎】多線程 標簽(空格分隔): javaweb 多線程 [TOC] 1、線程概念 簡單理解,一個客戶端可以同時做很多事,就是多線程 2、創建線程(三種方法) 1. 繼承線程類,例如: 2. 繼承線程類,例如: 3. 匿名類 to do more··· ...
  • django快速安裝指南 作為一個Python Web框架,Django需要Python環境。下麵是Django需要對應的python版本。 Django版本 python版本 1.11 2.7, 3.4, 3.5, 3.6, 3.7 (added in 1.11.17) 2.0 3.4, 3.5, ...
  • 歡迎訪問我的 "博客" 和 "github" ! go 語言學習筆記第一彈,來自 "gotour" ,以後要常寫筆記,把自己學習筆記記錄下來,就算只是筆記也要多寫。 好記性不如爛筆頭,也要多鍛煉自己的寫作能力。 說實話,今天很累了,最近在折騰操作系統內核,因為原先寫了個bootloader,現在想要 ...
一周排行
  • 1. 泛型Generic 1.1 引入泛型:延遲聲明 泛型方法聲明時,並未寫死類型,在調用的時候再指定類型。 延遲聲明:推遲一切可以推遲的。 1.2 如何聲明和使用泛型 泛型方法:方法名稱後面加上尖括弧,裡面是類型參數 類型參數實際上就是一個類型T聲明,方法就可以用這個類型T了。 如下所示: pub ...
  • 本筆記摘抄自:https://www.cnblogs.com/PatrickLiu/p/7903617.html,記錄一下學習過程以備後續查用。 一、引言 今天我們要講行為型設計模式的第三個模式--迭代器模式,先從名字上來看。迭代是遍歷的意思,迭代器可以理解為是遍歷某某的工具,遍歷什麼呢?在軟 件設 ...
  • 本筆記摘抄自:https://www.cnblogs.com/PatrickLiu/p/7928521.html,記錄一下學習過程以備後續查用。 一、引言 今天我們要講行為型設計模式的第四個模式--觀察者模式,先從名字上來看。觀察者模式可以理解為既然有“觀察者”,那肯定就有“被觀察者”了。“觀察者” ...
  • 先看核心代碼: public List<DataEntity> SearchShopSalesReport(DateTimeOffset? dateFrom, DateTimeOffset? dateTo,string groupBy) { var query = data.DataEntity / ...
  • 首先新建一個項目,名稱叫Caliburn.Micro.ActionConvertions 然後刪掉MainWindow.xaml 然後去app.xaml刪掉StartupUri這行代碼 其次,安裝Caliburn.Micro,Caliburn.Micro.Core,這兩個Nuget包,如下圖 然後新 ...
  • 一文帶你瞭解 C DLR 的世界 在很久之前,我寫了一片文章 "dynamic結合匿名類型 匿名對象傳參" ,裡面我以為DLR內部是用反射實現的。因為那時候是心中想當然的認為只有反射能夠在運行時解析對象的成員信息並調用成員方法。後來也是因為其他的事一直都沒有回過頭來把這一節知識給補上,正所謂亡羊補牢 ...
  • ​ 在C#8.0中,針對介面引入了一項新特性,就是可以指定預設實現,方便對已有實現進行擴展,也對面向Android和Swift的Api進行互操作提供了可能性。下麵我們來看看該特性的具體規則與實現。 一、主要應用場景: 在不破壞影響已有實現的情況下,可以添加新成員。這解決了在第三方已經大量使用了的介面 ...
  • 前言 通常在應用程式開發到正式上線,在這個過程中我們會分為多個階段,通常會有 開發、測試、以及正式環境等。每個環境的參數配置我們會使用不同的參數,因此呢,在ASP.NET Core中就提供了相關的環境API,方便我們更好的去做這些事情。 環境 ASP.NET Core使用ASPNETCORE_ENV ...
  • 擱置了幾天,工作忙的一塌糊塗,今天終於抽空來繼續看看MVC的知識。先來看看MVC的路由是如何處理的。以下為替代的路由: app.UseEndpoints(endpoints => { endpoints.MapControllerRoute( name: "default", pattern: "{ ...
  • 多用www.bing.com國際版解決代碼報錯 代碼運行的時候,報異常,國內的搜索引擎一搜, 浮誇的廣告太多,解決方案准確性不足, 盜版又很嚴重(導致一錯皆錯),方案未及時更新等詬病。 www.bing.com國際版可以關聯到: (1). 外國官網,可以獲得官方的解決方案。 (2). stackov ...
x