java - 深度克隆链表中的对象时遇到问题

Question

大家好，我在克隆方面遇到了麻烦。我正在尝试克隆列表中的对象。我成功克隆了我的列表和列表中的节点。但我在克隆存储在节点中的对象时遇到问题。下面是我的示例代码:我成功克隆了 Node 类和 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;
 }

我能够成功克隆列表和类 Node

在我的主要方法中，我能够将一组随机的国家和数据添加到列表中，并且能够毫无问题地克隆列表并修改 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;
 }

Answer 1

当你有一个类时，假设你有类 A、类 B 和类节点如果您从 A 类创建一个对象，其中包含 B 类对象的数组这个数组的每个元素都包含一些节点你应该克隆 A 的副本然后在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();

就是这样:)