Java IO面試題

1、Java 中有幾種類型的流？

按照流的方向：輸入流（inputStream）和輸出流（outputStream）

按照實現功能分：節點流（可以從或向一個特定的地方（節點）讀寫數據。如 FileReader）和處理流（是對一個已存在的流的連接和封裝，通過所封裝的流的功能調用實現數據讀寫。如 BufferedReader。處理流的構造方法總是要帶一個其他的流對象做參數。一個流對象經過其他流的多次包裝，稱為流的鏈接。）

按照處理數據的單位： 字節流和字符流。字節流繼承于 InputStream 和 OutputStream， 字符流繼承于InputStreamReader 和 OutputStreamWriter 。

2、字節流如何轉為字符流？

字節輸入流轉字符輸入流通過 InputStreamReader 實現，該類的構造函數可以傳入 InputStream 對象。

字節輸出流轉字符輸出流通過 OutputStreamWriter 實現，該類的構造函數可以傳入 OutputStream 對象。

3、如何將一個 java 對象序列化到文件里？

在 java 中能夠被序列化的類必須先實現 Serializable 接口，該接口沒有任何抽象方法只是起到一個標記作用。

public class Test {
    public static void main(String[] args) throws Exception {
        //對象輸出流
        ObjectOutputStream objectOutputStream =
                new ObjectOutputStream(new FileOutputStream(new File("D://obj")));
        objectOutputStream.writeObject(new User("zhangsan", 100));
        objectOutputStream.close();
        //對象輸入流
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("D://obj")));
        User user = (User) objectInputStream.readObject();
        System.out.println(user);
        objectInputStream.close();
    }
}

4、字節流和字符流的區別？

字節流讀取的時候，讀到一個字節就返回一個字節；字符流使用了字節流讀到一個或多個字節（中文對應的字節數是兩個，在 UTF-8 碼表中是 3 個字節）時。先去查指定的編碼表，將查到的字符返回。字節流可以處理所有類型數據，如：圖片，MP3，AVI視頻文件，而字符流只能處理字符數據。只要是處理純文本數據，就要優先考慮使用字符流，除此之外都用字節流。字節流主要是操作 byte 類型數據，以 byte 數組為準，主要操作類就是 OutputStream、InputStream字符流處理的單元為 2 個字節的 Unicode 字符，分別操作字符、字符數組或字符串，而字節流處理單元為 1 個字節，操作字節和字節數組。所以字符流是由 Java 虛擬機將字節轉化為 2 個字節的 Unicode 字符為單位的字符而成的，所以它對多國語言支持性比較好！如果是音頻文件、圖片、歌曲，就用字節流好點，如果是關系到中文（文本）的，用字符流好點。在程序中一個字符等于兩個字節，java 提供了 Reader、Writer 兩個專門操作字符流的類。

5、如何實現對象克隆？

有兩種方式：

● 實現 Cloneable 接口并重寫 Object 類中的 clone()方法；

● 實現 Serializable 接口，通過對象的序列化和反序列化實現克隆，可以實現真正的深度克隆，代碼如下：

class MyUtil {
    private MyUtil() {
        throw new AssertionError();
    }
    public static <T extends Serializable> T clone(T obj) throws Exception {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bout);
        oos.writeObject(obj);
        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bin);
        return (T) ois.readObject();
        // 說明：調用 ByteArrayInputStream 或 ByteArrayOutputStream 對象的 close 方法沒有任何意義
        // 這兩個基于內存的流只要垃圾回收器清理對象就能夠釋放資源，這不同于對外部資源（如文件流）的釋放
    }
}

測試代碼：

import java.io.Serializable;

/**
 * 人類
 */
class Person implements Serializable {
    private static final long serialVersionUID = -91020170202878978L;
    private String name; // 姓名
    private int age; // 年齡
    private Car car; // 座駕

    public Person(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

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

/**
 * 小汽車類
 */
class Car implements Serializable {
    private static final long serialVersionUID = -57138907627603702L;
    private String brand; // 品牌
    private int maxSpeed; // 最高時速

    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    @Override
    public String toString() {
        return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
    }
}

class CloneTest {
    public static void main(String[] args) {
        try {
            Person p1 = new Person("dujubin", 33, new Car("Benz", 300));
            Person p2 = MyUtil.clone(p1); // 深度克隆
            p2.getCar().setBrand("BYD");
            // 修改克隆的 Person 對象 p2 關聯的汽車對象的品牌屬性
            // 原來的 Person 對象 p1 關聯的汽車不會受到任何影響
            // 因為在克隆 Person 對象時其關聯的汽車對象也被克隆了
            System.out.println(p1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：基于序列化和反序列化實現的克隆不僅僅是深度克隆，更重要的是通過泛型限定，可以檢查出要克隆的對象是否支持序列化，這項檢查是編譯器完成的，不是在運行時拋出異常，這種是方案明顯優于使用 Object 類的 clone 方法克隆對象。讓問題在編譯的時候暴露出來總是好過把問題留到運行時。

6、什么是 java 序列化，如何實現 java 序列化？

序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化后的對象進行讀寫操作，也可將流化后的對象傳輸于網絡之間。序列化是為了解決在對對象流進行讀寫操作時所引發的問題。序 列 化 的 實 現 ： 將 需 要 被 序 列 化 的 類 實 現 Serializable 接 口 ， 該 接 口 沒 有 需 要 實 現 的 方 法 ， implements Serializable 只是為了標注該對象是可被序列化的，然后使用一個輸出流(如：FileOutputStream)來構造一個 ObjectOutputStream(對象流)對象，接著，使用 ObjectOutputStream 對象的 writeObject(Object obj)方法就可以將參數為 obj 的對象寫出(即保存其狀態)，要恢復的話則用輸入流。