Java基礎--常用API--IO流相關API

一、IO流

1、定義：

　　IO流指的是Input/Output流，即輸入流/輸出流。
　　　　輸入流：將外界信息寫入程序，即從外界獲取信息，屬於讀操作。
　　　　輸出流：將程序數據發送給外界，即向外界傳輸數據，屬於寫操作。
　　流一定要關閉，否則可能會出現一些異常。

2、分類：

　　（1）按照功能划分：
　　　　輸入流：只能讀數據，不能寫數據。
　　　　輸出流：只能寫數據，不能讀數據。
　　（2）按照處理單元划分：
　　　　字節流：讀寫字節，基類為InputStream/OutputStream。
　　　　字符流：讀寫字符，基類為Reader/Writer。（底層基於字節流進行操作，自動搜尋指定的編碼集合並轉換）
　　（3）按照角色划分：
　　　　節點流（低級流）：直接從外部設備中讀寫數據。
　　　　處理流（高級流）：處理一個已存在的流，不單獨存在。

3、常用類與接口：

　　JAVA中Ｉ/Ｏ處理的相關類庫主要存放在 java.io 包中。
　　　　基於字節操作的 I/O 類：InputStream 和 OutputStream
　　　　基於字符操作的 I/O 類：Reader 和 Writer
　　　　基於磁盤操作的 I/O 類：File
　　　　關閉I/O流的接口：Closeable
　　　　刷新I/O流的接口：Flushable
　　　　序列化接口：Serializable

 

二、字節流

1、字節輸入流：

　　字節輸入流的基類是InputStream，常用的子類是FileInputStream、BufferedInputStream。
　　（1）、InputStream
　　　　所有字節輸入流的父類。

常用方法：
    int read()// 讀取並返回1字節數據，若返回-1，表示讀到了輸入流的末尾。
    int read(byte[] b)// 將數據讀入一個字節數組，同時返回實際讀取的字節數。如果返回-1，表示讀到了輸入流的末尾。
    int read(byte[] b, int off, int len)//將數據讀入一個字節數組，同時返回實際讀取的字節數。如果返回-1，表示讀到了輸入流的末尾，off指定在數組b中存放數據的起始偏移位置；len指定讀取的最大字節數。
    long skip(long n)// 跳過和丟棄此輸入流中數據的n個字節
    void close()// 關閉此輸入流並釋放與該流關聯的所有系統資源。

　　

　　（2）、FileInputStream
　　　　文件字節輸入流，低級流。所有文件在系統中均以字節的形式保存，可以使用FileInputStream去讀取保存在硬盤上的字節序列。
　　　　在創建時，將文件名作為構造參數來創建FileInputStream，從而與文件間建立起字節流傳輸通道。
　　　　通過read()、read(byte[])、read(byte[], int begin, int len)三種方法從字節流中讀取一個字節或一組字節。

常用方法：
    繼承並重寫父類（InputStream）的方法。
    
構造方法：
    FileInputStream(File file)// 通過打開一個到實際文件的連接來創建一個FileInputStream，該文件通過文件系統中的File對象file指定
    FileInputStream(String name) // 通過打開一個到實際文件的連接來創建一個FileInputStream，該文件通過文件系統中的路徑name指定
    
樣例：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FISDemo{
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            // 注：此處的test.txt由自己新建,沒有的話會報異常的，此處我在文件內部寫了 “hello world”。
            fis = new FileInputStream("src" + File.separator + "test.txt");// 與文件建立個字節傳輸通道
            byte[] b = new byte[1024];// 用於保存從文件讀取的字節
            try {
                System.out.println("開始讀取文件");
                int len = 1;
                while ((len = fis.read(b)) != -1) {// 循環讀取文件
                    String str = new String(b, "utf-8");// 將字節數組轉為字符串
                    System.out.println(str);// 輸出
                }
                if (len == -1) {
                    System.out.println("文件讀取完畢");
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("讀取文件異常");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件異常");
        } finally {
            try {
                fis.close();// 關流
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("系統異常");
            }
        }
    }
}

結果：
    開始讀取文件
    hello world
    你好
    文件讀取完畢

 

　　（3）、BufferedInputStream
　　　　帶緩沖的字節輸入流，高級流。若直接從文件中存取字節流，則可能受硬件的影響導致傳輸速度慢，解決辦法：先在內存中建立一個緩沖區，每次將字節流從硬件中讀取到緩沖區中，然后從內存中讀取字節流。由於計算機與內存的交互速度比磁盤的交互速度快，所以效率會提高。

常用方法：
    繼承並重寫父類（InputStream）的方法。
    
構造方法：
     BufferedInputStream(InputStream in)// 創建一個BufferedInputStream並保存其參數，即輸入流in，以便將來使用。
     BufferedInputStream(InputStream in, int size) // 創建具有指定緩沖區大小的BufferedInputStream並保存其參數，即輸入流in以便將來使用

樣例：
    FileInputStream fis = new FileInputStream("src" + File.separator + "test.txt");// 與文件建立個字節傳輸通道
    BufferedInputStream bis = new BufferedInputStream(fis);//用於操作字節流 
    其余操作與FileInputStream類似

 

2、字節輸出流

　　字節輸入流的基類是OutputStream，常用的子類是FileOutputStream、BufferedOutputStream。
　　（1）、OutputStream
　　　　所有字節輸出流的父類。

常用方法：
    void write(byte[] b)// 將b.length個字節從指定的byte數組寫入此輸出流
    void write(byte[] b, int off, int len)// 將指定byte數組中從偏移量off開始的len個字節寫入此輸出流
    void write(int b)// 將1字節寫入此輸出流
    void close() // 關閉此輸出流並釋放與此流有關的所有系統資源
    void flush() // 刷新此輸出流並強制寫出所有緩沖的輸出字節

 

　　（2）、FileOutputStream
　　　　文件字節輸出流，低級流。所有文件在系統中均以字節的形式保存，可以使用FileOutputStream將字節流輸出並保存在硬件中。
　　　　在創建時，將文件名作為構造參數來創建FileOutputStream，從而與文件間建立起字節流傳輸通道。

常用方法：
    繼承並重寫父類（OutputStream）的方法。
    
構造方法：
    FileOutputStream(File file);//其中file指文件名
    FileOutputStream(String pathName);//其中pathName指文件路徑
    FileOutputStream(String pathName, boolean append);//其中append為true時，則表示向文件末尾追加數據，默認為false,即覆蓋數據。
    
樣例：
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FOSDemo {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("src" + File.separator + "test.txt");// 與文件間建立個通道，此時會覆蓋原文件
            String str = "How are you";
            byte[] b = str.getBytes();
            try {
                System.out.println("開始文件寫操作");
                fos.write(b);
                System.out.println("文件寫操作完成");
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("文件寫入異常");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件異常");
        }finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("系統異常");
            }
        }
    }
}

結果：
    開始文件寫操作
    文件寫操作完成
    
再次執行FISDemo.java后，結果為：
    開始讀取文件
    How are you
    文件讀取完畢

即覆蓋了原文件。

 

　　（3）、BufferedOutputStream
　　　　緩沖字節輸出流，高級流。將字節流輸出到緩沖區，通過flush方法可以將其寫入到硬件中。

常用方法：
    繼承並重寫父類（OutputStream）的方法。
    
構造方法：
     BufferedOutputStream(OutputStream out)// 創建一個新的緩沖輸出流，以將數據寫入指定的底層輸出流
     BufferedOutputStream(OutputStream out, int size)// 創建一個新的緩沖輸出流，以將具有指定緩沖區大小的數據寫入指定的底層輸出流
     
樣例：
    FileOutputStream fos = new FileOutputStream("src" + File.separator + "test.txt");// 與文件建立個字節傳輸通道
    BufferedOutputStreambis = new BufferedOutputStream(fos);//用於操作字節流 
    其余操作與FileOutputStream類似

 

三、字符流

　　注意：字符流只用於讀寫文本數據，不能用於讀取圖片等數據。

1、字符輸入流

　　

　　字符輸入流的基類是Reader。常用類為InputStreamReader，BufferedReader。
　　（1）Reader

常用方法：
    int read()// 讀取並返回1字符數據，若返回-1，表示讀到了輸入流的末尾。
    int read(char[] b)// 將數據讀入一個字符數組，同時返回實際讀取的字符數。如果返回-1，表示讀到了輸入流的末尾。
    int read(char[] b, int off, int len)//將數據讀入一個字符數組，同時返回實際讀取的字符數。如果返回-1，表示讀到了輸入流的末尾，off指定在數組b中存放數據的起始偏移位置；len指定讀取的最大字符數。
    long skip(long n)// 跳過和丟棄此輸入流中數據的n個字符
    void close()// 關閉此輸入流並釋放與該流關聯的所有系統資源。

 

　　（2）InputStreamReader
　　　　InputStreamReader是字符輸入流，可以在構造方法中設置字符集，並按照該編碼將字節數據轉為字符並讀取。

構造方法為：
    InputStreamReader(InputStream in);
    InputStreamReader(InputStream in, String charsetName);其中charsetName指utf-8、gbk等編碼集。

　　

　　（3）BufferedReader
　　　　BufferedReader是緩沖字符輸入流，以行為單位讀取字符串，其對應的應該為BufferedWriter，但其沒有PrintWriter用的爽。

構造方法：
    BufferedReader(Reader paramReader);

常用方法：
    String readLine();一次讀取一行字符串，若返回null,則表示無數據可讀。
    
字符流一般使用流程：
     FileInputStream fis = new FileInputStream("pw.txt"); //獲取文件輸入流
     InputStreamWriter isw = new InputStreamWriter(fis, "utf-8"); //按照指定編碼集包裝一下IO流
    BufferedReader br = new BufferedReader(isw);//使用緩沖字符流包裝一下IO流
    String str = null;
    while((str = br.readLine() ) != null){
        System.out.println(str);
    }
    fis.close();
    isw.close();
    br.close();

 

2、字符輸出流

　　字符輸出流的基類是Writer。常用類為OutputStreamWriter，PrintWriter。
　　（1）Writer

常用方法：
    void write(char[] b)// 將b.length個字符從指定的byte數組寫入此輸出流
    void write(char[] b, int off, int len)// 將指定byte數組中從偏移量off開始的len個字符寫入此輸出流
    void write(int b)// 將1字符寫入此輸出流。
    void write(String b)// 將字符串寫入此輸出流
    void close() // 關閉此輸出流並釋放與此流有關的所有系統資源
    void flush() // 刷新此輸出流並強制寫出所有緩沖的輸出字符

 

　　（2）OutputStreamWriter
　　　　OutputStreamWriter是字符輸出流，同樣可以在構造方法中設置字符集，按照字符集將字符轉為字節數據。

構造方法為：
    OutputStreamWriter(OutputStream out);
    OutputStreamWriter(OutputStream out, String charsetName);其中charsetName指utf-8、gbk等編碼集。

注：向文件寫入文本數據（字符串）的步驟
使用字符流時：
1、向文件中寫數據，FileOutputStream fos = new FileOutputStream("aa.txt"); 
2、寫文本數據，OutputStreamWriter osw = new OutputStreamWriter(fos);
或者OutputStreamWriter osw = new OutputStreamWriter(fos，”utf-8“);（建議使用）
3、寫字符串。

不使用字符流時，寫字符串一般采用：
fos.write("string".getBytes());將字符串轉為字節數組，再寫入文件。
使用字符流后，可以采用：
osw.write("string");因為字符流支持寫入字符串。

 

　　（3）PrintWriter
　　　　PrintWriter是緩沖字符輸入流，具有自動行刷新功能，即以行為單位寫出字符串。

構造方法：
    PrintWriter(File file);
    PrintWriter(String pathName);
    PrintWriter(OutputStreamWriter osw);
    PrintWriter(Writer writer);
    PrintWriter(OutputStreamWriter osw, boolean autoFlush);
    PrintWriter(Writer writer, boolean autoFlush);
    要想使用行刷新，必須有流作為參數。同時可以增加第二個參數，該參數為boolean值，該值為true時，則具有了自動行刷新功能。
    
普通方法:
    void println(String str); autoFlush為true時，自動調用flush()，每寫一行，換行，但會增加寫次數，降低效率。
    
使用流程：
使用默認編碼集：
PrintWriter pw = new PrintWriter("pw.txt");
pw.println("你好");
pw.close();

使用自定義編碼集：（建議）
FileOutputStream fos = new FileOutputStream("pw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, “utf-8”);
PrintWriter pw = new PrintWriter(osw, true);
pw.println("你好");
pw.close();

舉例：
使用緩沖字符流讀每一行字符串，然后將字符串拼接，最后在向文件追加寫操作，寫入文件。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class Test {
    public static void main(String[] args) throws IOException {
        // 使用字節流讀取文件
        FileInputStream fis = new FileInputStream("a.txt");
        // 使用字符流，並指定字符集
        InputStreamReader isr = new InputStreamReader(fis, "utf-8");
        // 使用緩沖字符流
        BufferedReader br = new BufferedReader(isr);
        // 使用StringBuilder，便於字符串的拼接
        StringBuilder sb = new StringBuilder();
        String str = null;
        // 循環讀取每行字符串，並拼接
        while ((str = br.readLine()) != null) {
            sb.append(str);
        }
        // 將StringBuilder的值轉為字符串
        str = sb.toString();

        // 使用字節流寫入文件
        FileOutputStream fos = new FileOutputStream("a.txt", true);
        // 使用字符流，並指定字符集。
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
        // 使用緩沖輸出流
        PrintWriter pw = new PrintWriter(osw, true);
        // 寫入文件
        pw.println(str);

        // 關流
        fis.close();
        isr.close();
        fos.close();
        osw.close();
        br.close();
        pw.close();
    }
}

 

 四、字節流補充

1、序列化流（ObjectOutputStream，ObjectInputStream）

　　序列化：將一個特定數據結構轉為一組字節的過程。

　　反序列化：將一組字節轉為特定的數據結構。

　　持久化：將數據寫入硬盤長久保存。

　　序列化、反序列化一般用於傳輸以及保存數據。

　　ObjectOutputStream用於序列化，ObjectInputStream用於反序列化。是一組高級流。實現序列化需要實現serializable接口。使用transient關鍵字修飾的成員變量不參與序列化過程。

常用方法：
    void writeObject(Object o);序列化，將對象轉為字節寫入文件。
    Object readObject();反序列化，將文件中字節轉為對象。
    
樣例：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * 需被序列化的類，要實現Serializable接口
 * 
 * @author EBT
 *
 */
class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private Integer age;
    private List<String> name;

    public Person(Integer age, List<String> name) {
        this.age = age;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public List<String> getName() {
        return name;
    }

    public void setName(List<String> name) {
        this.name = name;
    }

    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }
}

/**
 * 測試類，測試序列化
 * 
 * @author EBT
 *
 */
public class SerializableDemo {
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        name.add("張三");
        name.add("李四");

        Person person = new Person(18, name);
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream("src" + File.separator + "test.txt");
            try {
                oos = new ObjectOutputStream(fos);
                System.out.println("開始序列化");
                oos.writeObject(person);
                System.out.println("序列化完成");
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("序列化異常");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件異常");
        } finally {
            try {
                fos.close();
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("系統異常");
            }
        }

        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream("src" + File.separator + "test.txt");
            try {
                ois = new ObjectInputStream(fis);
                try {
                    System.out.println("\n\n開始反序列化");
                    Person people = (Person) ois.readObject();
                    System.out.println(people);
                    System.out.println("反序列化結束");
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                    System.out.println("反序列化異常");
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("系統異常");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件異常");
        } finally {
            try {
                fis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("系統異常");
            }
        }
    }
}

結果：
    開始序列化
    序列化完成


    開始反序列化
    Person [age=18, name=[張三, 李四]]
    反序列化結束

調用FISDemo.java后，可以看到序列化結果為（如下圖）：

 

五、File類

1、定義：

　　是文件和目錄的路徑名的抽象表示。
　　File類保存文件或目錄的各種元數據信息，包括文件名、文件長度、最后修改時間、是否可讀、獲取當前文件的路徑名，判斷指定文件是否存在、獲得當前目錄中的文件列表，創建、刪除文件和目錄等方法。

注意：File能創建、刪除文件，但不能改變文件里的內容。

格式為：
File file = new File("src" + File.separator + "demo.txt");
File.separator表示斜杠（正斜杠、反斜杠）。

或者
File file = new File("src/demo.txt");

 

2、方法：

　　（1）文件、目錄的創建方法
　　　　boolean createNewFile() 不存在返回true 存在返回false。需要拋異常throws IOException。
　　　　boolean mkdir() 創建目錄
　　　　boolean mkdirs() 創建多級目錄

　　（2）文件刪除方法　　
　　　　boolean delete() 刪除文件或者文件夾（文件夾必須為空才可以被刪除，即每次刪除單個文件或文件夾）
　　　　void deleteOnExit() 文件使用完成后刪除

　　（3）文件移動方法
　　　　boolean renameTo(File f) 文件改名（移動）

　　（4）判斷方法
　　　　boolean canExecute() 判斷文件是否可執行
　　　　boolean canRead() 判斷文件是否可讀
　　　　boolean canWrite() 判斷文件是否可寫
　　　　boolean exists() 判斷文件是否存在
　　　　boolean isDirectory() 判斷是否為文件夾
　　　　boolean isFile() 判斷是否為文件
　　　　boolean isHidden() 判斷是否隱藏
　　　　boolean isAbsolute() 判斷是否是絕對路徑（文件不存在也能判斷）

　　（5）獲取方法
　　　　String getName() 用於獲取File表示的文件名
　　　　String getPath() 獲取路徑
　　　　String getAbsolutePath() 獲取絕對路徑
　　　　String getParent() 獲取父目錄，如果沒有父目錄返回null
　　　　long lastModified() 獲取文件最后一次修改的時間，是個毫秒值
　　　　long length() 獲取文件所占用的字節量。　　
　　　　String[] list() 獲得文件（夾）名列表
　　　　String[] list(FilenameFilter filter) 獲得文件（夾）名列表(帶過濾條件)
　　　　File[] listFiles() 獲得子文件（夾）數組
　　　　File[] listFiles(FilenameFilter filter) 獲得子文件（夾）數組(帶過濾條件)

舉例;（獲取當前目錄所在的所有文件）
import java.io.File;
import java.io.FileFilter;

import java.io.File;
import java.io.FileFilter;

//自定義過濾器
class MyFilter implements FileFilter {

    // 繼承FileFilter需要重寫accept方法
    @Override
    public boolean accept(File file) {
        return file.getName().endsWith(".txt");
    }

}

public class Test {
    public static void main(String[] args) {
        File dir = new File("src/proxyDemo");
        // 不使用過濾器，則輸出所有抽象路徑名數組
        if (dir.isDirectory()) { // 是目錄
            File[] subs = dir.listFiles();
            System.out.println("不使用過濾器，文件個數為：" + subs.length);
            for (File sub : subs) {
                System.out.println(sub.getName() + " ,長度" + sub.length());
            }
        }

        System.out.println();
        System.out.println();
        // 使用過濾器，輸出符合條件的抽象路徑名數組
        if (dir.isDirectory()) {
            MyFilter filter = new MyFilter();
            File[] subs = dir.listFiles(filter);
            System.out.println("使用過濾器, 文件個數為： " + subs.length);
            for (File sub : subs) {
                System.out.println(sub.getName() + " ,長度" + sub.length());
            }
        }
    }
}


舉例： （創建多級目錄下的一個文件）
創建文件時，需要先判斷其目錄是否存在，如果不存在目錄，創建時會報錯。
import java.io.File;
import java.io.IOException;

public class Test{
    public static void main(String[] args) throws IOException{
        File file = new File("aa" + File.separator + "b" + File.separator + "c" + File.separator + "d.txt");
        File parent = file.getParentFile();
        //不存在路徑時，需創建，否則會報錯
        if(!parent.exists()) {
            parent.mkdirs();
        }
        //如果文件不存在，則創建
        if(!file.exists()) {
            file.createNewFile();
            System.out.println("文件創建成功！");
        }else {
            System.out.println("文件已存在！");
        }
    }
    
}

舉例：（刪除給定文件或多級目錄）
刪除多級目錄時，可以使用delete刪，但是delete只能刪除單個文件或目錄。
所以，如果刪除某個目錄A下還有目錄B，則需進入目錄B刪除其所有內容，若存在C目錄，同理刪除，可以采用遞歸實現。
import java.io.File;
public class Test{
    public static void main(String[] args){
        File file = new File("a");
        deleteFile(file);
        System.out.println("刪除成功");
    }
    //遞歸刪除，如果某目錄下還有目錄，則進入目錄繼續判斷，從最后一層開始往上刪。
    public static void deleteFile(File file) {
        if(file.isDirectory()) {
            File[] subs = file.listFiles();
            for(File sub : subs) {
                deleteFile(sub);
            }
        }
        file.delete();
    }
}

 

六、RandomAccessFile類

1、規則：

　　（1）使用該類可以讀取文件里的內容。
　　（2）該類基於指針的操作，總是在當前指針的位置讀寫字節。
　　（3）對文件有兩種訪問方式，一個只讀模式（r），一個讀寫模式（rw）。

2、構造方法：

　　（1）RandomAccessFile(File file, String mode)
　　（2）RandomAccessFile(String pathName, String mode).
注：pathName指的是文件的路徑。mode指的是r或者rw。

3、普通方法：

　　（1）void write(int n)，向文件中寫東西，只寫一個字節，低八位。從文件最開始的地方開始寫。
　　（2）void write(byte[] b) ，向文件中寫入字節數組。
　　（3） void write(byte[] b, int start, int len),指從start處開始，連續寫入len個字節。
　　（4）void writeInt(int num); 連續寫入四個字節，寫入一個完整int值。
　　（5）void writeDouble(double num); 寫入一個完整double值。
　　（6）int read();從文件中讀東西，只讀一個字節，低八位。通常返回一個不為-1的的值，若返回-1，則表示讀取到文件的末尾。
　　（7）int read(byte[] b)，從文件中一次讀出多個字節，返回的是實際讀取的字節數。
　　（8）long getFilePointer();獲取當前指針位置
　　（9）void seek(long position);指定指針所在位置，從指定位置進行讀寫操作。
　　（10）int skipBytes(int n); 嘗試跳過n個字節，返回實際跳過字節數。
　　（11）void close(); 關閉流。

舉例：
使用RandomAccessFile實現文件的復制：
步驟：
1、創建一個RandomAccessFile ,用於讀（r）。
2、創建一個RandomAccessFile，用於寫（rw）。
3、循環讀寫操作。
4、關閉兩個輸入輸出流。

import java.io.IOException;
import java.io.RandomAccessFile;

public class Test {
    public static void main(String[] args) throws IOException {
        // 先創建兩個流，用於讀取以及寫入數據
        RandomAccessFile rafWrite = new RandomAccessFile("a.txt", "rw");
        RandomAccessFile rafRead = new RandomAccessFile("copy.txt", "rw");

        // 使用getBytes()，將字符串轉為字節數組。
        // getBytes("utf-8")支持重載方法，使用指定編碼集轉為字節數組
        String str = "安徽師范大學";
        byte[] b = str.getBytes("utf-8");
        // 批量寫入數據，此時指針位於文件末尾
        rafWrite.write(b);

        // 由於RandomAccessFile基於指針操作，需將指針移到指定位置。
        rafWrite.seek(0);

        int d = -1;
        // 每次循環讀一個字節，並寫一個字節
        while ((d = rafWrite.read()) != -1) {
            rafRead.write(d);
        }

        // 讀出復制后的數據，先將指針移至指定位置
        rafRead.seek(3);
        // 讀數據由於讀出的是字節，需要將其轉為字符串輸出
        byte[] r = new byte[10240];
        int len = rafRead.read(r);
        // 使用重載方法，也可以去掉utf-8這個參數，根據實際情況可能造成亂碼問題
        String str1 = new String(r, "utf-8");
        System.out.println(str1); // 輸出 徽師范大學，utf-8中中文占三個字節，GBK中占兩個字節。

        rafWrite.close();
        rafRead.close();
    }
}

 

七、Properties文件讀取

1、使用Properties類讀取文件

假定在src目錄下有一個配置文件file.properties
文件內容如下：
    name = lyh
    pwd = 123456
    
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class Test {
    public static void main(String[] args) throws IOException {
        InputStream is = ClassLoader.getSystemResourceAsStream("file.properties");
        Properties properties = new Properties();
        properties.load(is);
        System.out.println(properties.getProperty("name"));
    }
}

 

2、使用ResourceBundle類讀取文件

假定在src目錄下有一個配置文件file.properties
文件內容如下：
    name = lyh
    pwd = 123456
    
ResourceBundle resourceBundle = ResourceBundle.getBundle("file");
System.out.println(resourceBundle.getString("pwd"));

舉例：
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.ResourceBundle;

public class Test {
    public static void main(String[] args) throws IOException {
        InputStream is = ClassLoader.getSystemResourceAsStream("file.properties");
        Properties properties = new Properties();
        properties.load(is);
        System.out.println(properties.getProperty("name"));

        ResourceBundle resourceBundle = ResourceBundle.getBundle("file");
        System.out.println(resourceBundle.getString("pwd"));
    }
}

輸出：
lyh
123456

 

 

未完待續...........................................