Java-深度克隆具有多种类型元素的向量

我有一些下面的示例代码来自我正在从事的一个项目。在其中，我需要将向量v的元素深度克隆到向量w中。换句话说，每个元素都需要引用其在内存中的位置

在我的程序中，我需要创建不同类型的对象并将它们添加到向量中。然后我需要克隆该向量中的每个元素（意味着给它们在内存中的位置），并将这些克隆的元素添加到新的向量中。问题是，当程序员不知道对象类型时，我不知道如何克隆。如果每个元素都是相同的类型，我可以直接转换为该类型。但事实并非如此

在我的代码中，我确保给定的元素实现了可克隆性，但我不知道如何进行实际的克隆。（可能是以某种方式强制转换为正确的类型，然后调用clone（）或其他方式。）

谢谢。下面是我的代码，非常感谢您的帮助

import java.util.*;

public class Test {
    public static void main(String[] arguments) {
        // Establish variables
        Point p1 = new Point();
        Point p2 = new Point(1, 2);
        A a1 = new A();
        A a2 = new A(1);

        // Create vector v and add variables to vector
        Vector v = new Vector();
        v.add(p1);
        v.add(p2);
        v.add(a1);
        v.add(a2);

        // Change p1.x
        p1.x = 1;

        // Create vector w and assign elements from v into vector
        Vector w = new Vector();
        int n = v.size();
        for (int i = 0; i < n; i++)
            if (v.get(i) instanceof Cloneable)
                w.add(v.get(i));

        // print elements in vectors
        System.out.println(v);
        System.out.println(w); //elements seem to reference the same area in memory
    }
}

class Point implements Cloneable {
    int x;
    int y;

    Point() {
        x = 0;
        y = 0;
    }

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public Object Clone() {
        try {return super.clone();}
        catch (CloneNotSupportedException exception) {return null;}
    }

    public String toString() {return "Point[x=" + x + ",y=" + y + "]";}
}

class A implements Cloneable {
    int i;

    A() {i = 0;}

    A(int i) {this.i = i;}

    public Object Clone() {
        try {return super.clone();}
        catch (CloneNotSupportedException exception) {return null;}
    }

    public String toString() {return "A[i=" + i + "]";}
}

import java.util.*；
公开课考试{
公共静态void main（字符串[]参数）{
//建立变量
点p1=新点（）；
点p2=新点（1,2）；
a1=新的A（）；
a2=新的A（1）；
//创建向量v并向向量添加变量
向量v=新向量（）；
v、 添加（p1）；
v、 添加（p2）；
v、 添加（a1）；
v、 添加（a2）；
//更改p1.x
p1.x=1；
//创建向量w并将元素从v分配到向量
向量w=新向量（）；
int n=v.size（）；
对于（int i=0；i

您可以对整个向量进行深度序列化，而不是序列化单个元素

  public static <T extends Serializable> T deepCopyOfSerializable(T o) throws Exception
{
    if (o == null)
        return null;

    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bos);

    oos.writeObject(o);
    bos.close();
    oos.close();

    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);

    T t = (T) ois.readObject();
    bis.close();
    ois.close();
    return t;
}

public static T deepCopyOfSerializable（TO）抛出异常
{
如果（o==null）
返回null；
ByteArrayOutputStream bos=新建ByteArrayOutputStream（）；
ObjectOutputStream oos=新的ObjectOutputStream（bos）；
oos.writeObject（o）；
bos.close（）；
oos.close（）；
ByteArrayInputStream bis=新的ByteArrayInputStream（bos.toByteArray（））；
ObjectInputStream ois=新ObjectInputStream（bis）；
T=（T）ois.readObject（）；
二、关闭（）；
ois.close（）；
返回t；
}

但是为什么要使用向量呢？我会非常非常小心的。可克隆性通常是程序员在Java中最容易出错的事情之一。您正在做一个巨大的假设，即每个实现cloneable的类都将执行您正在寻找的深度复制。遗憾的是，这没有起作用。它抛出了一个NotSerializableException，可能是因为里面的对象不可序列化？是的。每个实体都必须是可序列化的