无法深入克隆链接列表中的对象
你好，我在克隆方面遇到了麻烦。 我正在尝试在列表中克隆一个对象。 我成功地克隆了我的列表和列表中的节点。 但我无法克隆存储在节点中的对象。 以下是我的示例代码：我成功克隆了类节点和类B，但未成功克隆类B中的类A，因为我试图用克隆LinkedList修改类A，并通过打印出原始文件来验证其深层副本内容和克隆的内容，并且能够在不修改原始内容的情况下修改克隆的内容。 基本上我的程序是从一个文件中读取并存储一个国家的统计单元格数据，从1960年到2012年。我能够从文件中成功读取数据，但现在我正在尝试制作一个深度副本。 我在尝试修改A时无法为A类制作深层副本，但它影响了原始列表。 起初它给了我数组越界，但现在当我修改一年和它的数据时，它也修改了原始列表，而不仅仅是克隆的列表。 我究竟做错了什么。 我知道它有很多代码，但是我简单简洁，如果有人能帮忙，请不要忽略任何重要细节。 我想了解深层复制。
Class A implements Cloneable{
private int year;
private double data;
A(int double, double data)
{
setInt(year);
setDouble(data);
}
public void setInt(int year)
{
this.year = year;
}
public void setDouble(double data)
{
this.data = data;
}
public int getYear()
{
return year;
}
public double getData()
{
return data;
}
public Object clone()
{
A clonedA = new A(this.getYear(), this.getData());
}}
class B implements Cloneable{
private A[] a;
private String name;
private int arraylength;
private int index;
public B(String name, int length)
{
this.name = name;
this.arraylength = length;
a = new A[array.length];
index = 0;
}
public void addToA(int year, double data)
{
a[index] = new A(year, data);
index++;
}
public String getName(){
return name; }
public int getLength(){
return array length;}
public void setName(String name)
{
this.name= name
}
public Object clone()
{
B clonedB = new B(this.getName(), this.getLength());
for(A clonedArray: a)
{
clonedB.addToA(clonedArray.getYear(), clonedArray.getData());
}
return clonedB;
}
我成功克隆在下面的列表中
class Node implements Cloneable{
B objectB;
Node next;
public Node(B objectB)
{
this.objectB = objectB;
this.next = null;
}
public void setNode(B node)
{
this.next = node;
}
public Node getNext()
{
this.next;
}
public B getObjectB()
{
return objectB;
}
public Object clone()
{
Node newNode = new Node(this.getObjectB);
newNode.objectB = (B)this.getB().clone
return newNode;
} }
class LinkedList implements Cloneable{
private Node head;
public LinkedList()
{
head = null
}
public boolean isEmpty()
{
return (head==null);
}
public void addEndOfList(B b)
{
Node newNode = new Node(b);
if(this.isEmpty())
{
newNode.set(head);
head = newNode;
}
else {
Node current = head;
while(current.getNext!=null)
{
current = current.getNext();
}
current.set(newNode);
}
public void setName(String name)
{
if(this.isEmpty()
{
System.out.println("Cannot modify an empty list" );
}
else{
first.getObjectB().setName(name);
}
}
public void modifyA(int year, double stat)
{
if(this.isEmpty()
{
System.out.println("Cannot modify an empty list" );
}
else{
first.getObjectB().addTOA(year, stat);
}
}
public Object clone()
{
LinkedList newList = new LinkedList();
Node current = first;
while(current!=null)
{
Node clonedCurrent = (Node)current.clone();
newList.add(clonedCurrent.getObjectB())
current = current.getNext();
}
returned newList;
}
我能够成功克隆列表和类节点
在我的主要方法中，我能够将随机的一组国家和数据添加到列表中，并能够克隆列表并在B中修改名称，没有任何问题。 但是，由于克隆列表试图修改类A而没有成功，因此我无法深入克隆类A。 我在类中检查了我的克隆方法，并且没有克隆类A.我在调试时遇到了麻烦。 请帮助我一些帮助。
private LinkedList createCloneList(B []b, int selectSize)
{
Random rand = new Random()
LinkedList selectB = new LinkedList();
for(int i = 0; i<selectSize;i++)
{
int index = random.nextInt(b.length);
selectB.addEndOfList(b[index]);
}
return selectB;
}
private LinkedList testCloneable(LinkedList listOfB)
{
LinkedList clonedList = (LinkedList)listofB.clone();
clonedList.setName("NewName");
clonedList.modifyA(0, 12.56);//0 being the first index position of the stat 12.56
return clonedList;
}
当你有一个类可以说你有类A，类B和类节点，如果你从类A创建一个包含来自类B的对象数组的对象，并且这个数组的每个元素包含一些节点，你应该克隆然后在类A的同一个克隆函数中，你也克隆了类型B的数组，这也是非常重要的，你应该通过它克隆数组中的每一个元素，所有这些都在类A的克隆方法中
在B类方法中，您应该克隆B的副本，这里的副本是我们的B类型数组，或者它是数组中类型B的对象元素（B [0]，B [1] ....等等）和任何条目中的每个节点也应该被克隆。
这里是一个例子：
//class A
public class A implements Cloneable{
B [] array;
.
.
.
public Object clone() throws CloneNotSupportedException {
A copyA = null;
try {
copyA = (A) super.clone();
}
catch (CloneNotSupportedException e) {
// this should never happen
throw new InternalError(e.toString());
}
copyA.array = array.clone();
for (int i=0;i<array.length;i++)
copyA.array[i] = (B) array[i].clone();
return copyA;
}
}
//class B
public class B implements Cloneable{
Node topnode;
Node bottom;
.
.
.
public Object clone() throws CloneNotSupportedException {
B copyB = null;
try {
copyB= (B) super.clone();
}
catch (CloneNotSupportedException e) {
// this should never happen
throw new InternalError(e.toString());
}
return copyB;
}
}
//class Node
public class Node implements Cloneable{
.
.
.
.
public Object clone() throws CloneNotSupportedException {
Node copyNode = null;
try {
copyNode = (Node) super.clone();
}
catch (CloneNotSupportedException e) {
// this should never happen
throw new InternalError(e.toString());
}
return copyNode;
}
}
/*in your main class
if you already have you original object of class A lets say original
and you want to clone it to copy you just do */
A copy =(A) original.clone();
这就是它:)
链接地址: http://www.djcxy.com/p/40789.html