Häufige Interviewfragen zum Kopieren von Java-Objekten

Warum Klonen verwenden? (Empfohlenes Lernen: Häufige Java-Testfragen )

Wenn Sie mit einem Objekt umgehen und die Originaldaten für den nächsten Vorgang behalten möchten, müssen Sie es klonen , Java-Klonen in der Sprache ist für Instanzen von Klassen.

Wie implementiert man das Klonen von Objekten?

Es gibt zwei Möglichkeiten:

Implementieren Sie die Cloneable-Schnittstelle und überschreiben Sie die clone()-Methode in der Object-Klasse. Implementieren Sie die Serializable-Schnittstelle und serialisieren Sie das Objekt und Deserialisierung, um ein echtes tiefes Klonen zu erreichen. Der Code lautet wie folgt:

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class MyUtil {

    private MyUtil() {
        throw new AssertionError();
    }

    @SuppressWarnings("unchecked")
    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方法没有任何意义
        // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
    }
}

Das Folgende ist der Testcode:

import java.io.Serializable;

/**
 * 人类
 * @author nnngu
 *
 */
class Person implements Serializable {
    private static final long serialVersionUID = -9102017020286042305L;

    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 + "]";
    }

}

/**
 * 小汽车类
 * @author nnngu
 *
 */
class Car implements Serializable {
    private static final long serialVersionUID = -5713945027627603702L;

    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("郭靖", 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();
        }
    }
}

Hinweis : Das auf Serialisierung und Deserialisierung basierende Klonen ist nicht nur ein tiefes Klonen, sondern, was noch wichtiger ist, Sie können überprüfen, ob das zu klonende Objekt die Serialisierung unterstützt, und nicht zur Laufzeit Ausnahme ist diese Lösung offensichtlich besser als die Verwendung der clone-Methode der Object-Klasse zum Klonen des Objekts. Es ist immer besser, Probleme zur Kompilierzeit offenzulegen, als sie zur Laufzeit zu belassen.

Was ist der Unterschied zwischen Deep Copy und Shallow Copy?

Flache Kopie kopiert nur die Referenzadresse des Objekts. Die beiden Objekte zeigen auf dieselbe Speicheradresse. Wenn also ein Wert geändert wird, ändert sich der andere Wert entsprechend. Dies ist eine flache Kopie (. Beispiel: „assign()“ Deep Copy dient zum Kopieren des Objekts und seines Werts. Wenn ein Wert der beiden Objekte geändert wird, wird der andere Wert nicht geändert. Dies ist eine tiefe Kopie (zum Beispiel: JSON.parse()). JSON.stringify(), aber diese Methode kann den Funktionstyp nicht kopieren)

Das obige ist der detaillierte Inhalt vonHäufige Interviewfragen zum Kopieren von Java-Objekten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!