Как я могу создать глубокую копию этого связанного списка?

---

Все, что я пробовал, не сработало при попытке создать глубокую копию этого связанного списка, который создается. Всякий раз, когда я пытаюсь использовать базовую реализацию из своего учебника, она не работает, потому что int не может быть разыменован.

Что я уже пробовал:

Я попытался использовать базовую реализацию, которую дает мне моя книга(перечисленную ниже), и изменить переменные, чтобы они соответствовали, но это все равно не сработает. Он выдает ошибки, говорящие о том, что мой класс LLwithNodeLab не может содержать аргументы, которые я ему даю.

import java.io.*;
public class LLwithNodeLab implements Cloneable {
    private Node head;
    private int listCount;

    public static void main(String[] args) {
        LLwithNodeLab list = new LLwithNodeLab();
        String data = "LLLabFall2020";
        
        for (int x=0; x<data.length(); x++){
            list.add(data.substring(x,x+1));
        }
        
        System.out.println("Original list:");
        System.out.println(list);
        
        int index = ((int)(Math.random()*10))%list.size() + 1;
        System.out.println("Getting item at index " + index);
        System.out.println(list.get(index)+ " retrieved");
        
        index = ((int)(Math.random()*10))%list.size() + 1;
        System.out.println("Removing item at index " + index);
        list.remove(index);
        System.out.println("Revised list:");
        System.out.println(list);
        
        System.out.println("Looking for " + data.charAt(index));
        System.out.println("Found at index: " + list.listSearch(""+data.charAt(index)));
        System.out.println("Looking for " + "X");
        System.out.println("Found at index: " + list.listSearch("X"));
        
        System.out.println("Removing first item:");
        list.remove(1);
        System.out.println("Revised list:");
        System.out.println(list);
        
        System.out.println("Removing last item");
        list.remove(list.size());
        System.out.println("Revised list:");
        System.out.println(list);
        
        index = ((int)(Math.random()*1000))%list.size() + 1;
        System.out.println("Adding new item at position " + index);
        list.add(""+Math.random(), index);
        System.out.println("Revised list:");
        System.out.println(list);
        
        System.out.println("Testing listPart:");
        int first = ((int)(Math.random()*10))%list.size() + 1;
        int second = ((int)(Math.random()*10))%list.size() + 1;
        while (first >= second) second++;
        while (second > list.size()) {
            second--;
            first--;
        }
        System.out.println("Copying list from index " + first + " to index " + second);
        LLwithNodeLab fragment = list.listPart(first,second);
        System.out.println("Result:");
        System.out.println(fragment);
        
       
        if (fragment != null) {
            System.out.println("Testing clone on partial list:");
            LLwithNodeLab copy = fragment.clone();
            System.out.println("Result:");
            System.out.println(copy);
        }

    }

        

    public LLwithNodeLab() {
        // this is an empty list, so the reference to the head node
        // is set to a new node with no data
        head = new Node(null);
        listCount = 0;
    }

    public void add(Object data)    {
        // post: appends the specified element to the end of this list.
        Node temp = new Node(data);
        Node current = head;
        while(current.getNext() != null) {
            current = current.getNext();
        }
        current.setNext(temp);
        temp.setBack(current);
        listCount++;// increment the number of elements variable
    }

    public void add(Object data, int index) {
        // post: inserts the element at the specified position in this list.
        Node temp = new Node(data);
        Node current = head;
        for(int i = 1; i < index && current.getNext() != null; i++) {
            current = current.getNext();
        }
        temp.setNext(current.getNext());
        temp.setBack(current);
        current.getNext().setBack(temp);
        current.setNext(temp);
        listCount++;// increment the number of elements variable
    }

    public Object get(int index) {
        // post: returns element at specified position (must be >=1) in this list.
        if(index <= 0)
            return null;
        Node current = head.getNext();
        for(int i = 1; i < index; i++) {
            if(current.getNext() == null)
                return null;
            current = current.getNext();
        }
        return current.getData();
    }      

    public int size() {  // post: returns number of elements in list.    
        return listCount;
    }

    public String toString() {
        Node current = head.getNext();
        String output = "|||";
        while(current != null) {
            output += "<=[" + current.getData().toString() + "]=>";
            current = current.getNext();
        }
        output = output + "|||";
        return output;
    }

    private class Node {
        // reference to next node in chain, or null if there isn't one.
        Node next;
        // reference to previous node, or null if there isn't one
        Node back;
        // data carried by this node.
        Object data;
        public Node(Object _data) {
            next = null;
            back = null;
            data = _data;
        }

        public Node(Object _data, Node _next, Node _back) {
            next = _next;
            back = _back;
            data = _data;
        }

        public Object getData() {
            return data;
        }

        public void setData(Object _data) {
            data = _data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node _next) {
            next = _next;
        }

        public Node getBack() {
            return back;
        }

        public void setBack(Node _back) {
            back = _back;
        }
    } // end of inner Node class

    
    // Modify this method so that it works properly for
    // a doubly-linked list; ensure that the node at 
    // index + 1 (if it exists) points back to current
    // before the method returns
    public boolean remove(int index)    {
        // post: removes element at specified position in this list.
        if(index < 1 || index > size())
            return false;
        Node current = head;
        for(int i = 1; i < index; i++)  {
            if(current.getNext() == null)
                return false;
            current = current.getNext();
        }
        current.setNext(current.getNext().getNext());
        if(current.getNext() != null){
            current.getNext().setBack(current);
        }
        listCount--; // decrement the number of elements variable
        return true;
    }

    
    // returns the index where the target item is located or -1 if
    // not found
    public int listSearch(Object target) {
        Node cursor = head.getNext();
        Node checkafter = cursor.getNext();
        int index;
        boolean isFound = false;
        while(isFound = false){
        for(index=1; cursor!=null && cursor.getData().equals(target);index++){
            isFound = true;
            cursor = cursor.getNext();
            return index;
        }
    }
        return -1;
    }
    
       
    

    // returns a copy of the portion of the list from index start to
    // index end; preconditions: start < end, start >= 1, end <= size()
    public LLwithNodeLab listPart (int start, int end) {
        System.out.println("listSearch not done yet");
        return null;
        
    }

    // returns a deep copy of the calling object
     public LLwithNodeLab clone() {
         return null;
    }

  }

Базовая реализация из моей книги:

public static IntNode listCopy(IntNode souce)
    {
IntNode copyHead;
IntNode copyTail;
// Handle the special case of an empty list.
if (source == null)
return null;
// Make the first node for the newly created list.
copyHead = new IntNode(source.data, null);
copyTail = copyHead;
// Make the rest of the nodes for the newly created list.
while (source.link != null)
{
source = source.link;
copyTail.addNodeAfter(source.data);
copyTail = copyTail.link;
}
// Return the head reference for the new list.
return copyHead;
}

---