Java中的双重链接列表正在抛出异常(堆栈溢出异常)

Question

我有一个双重链接列表实现，如下所示。但是，当我试图打印列表时，我会得到堆栈溢出例外。我不确定，但看起来与覆盖ToString（）方法有关。有人可以解释到底发生的事情，这导致了这个问题。

        // Main function class
        public class Main {
            public static void main(String[] args) {
                DoublyLinkedList list = new DoublyLinkedList();
                list.insertAtStart(2);
                list.insertAtStart(3);
                list.insertAtStart(4);
                list.insertAtStart(5);
                list.insertAtStart(6);
                list.insertAtStart(7);
                list.print();
            }
        }
        // Doubly node class
        public class DoublyLinkedListNode {
            private int data;
            private DoublyLinkedListNode next;
            private DoublyLinkedListNode prev;
            public DoublyLinkedListNode(int data)
            {
                this.data = data;
            }
            public int getData() {
                return data;
            }
            public void setData(int data) {
                this.data = data;
            }
            public DoublyLinkedListNode getNext() {
                return next;
            }
            public void setNext(DoublyLinkedListNode next) {
                this.next = next;
            }
            public DoublyLinkedListNode getPrev() {
                return prev;
            }
            public void setPrev(DoublyLinkedListNode prev) {
                this.prev = prev;
            }
            @Override
            public String toString() {
                return "DoublyLinkedListNode{" +
                        "data=" + data +
                        ", next=" + next +
                        ", prev=" + prev +
                        '}';
            }
        }
        // Here I have created function for inserting and printing the elemnts in doubly linked list
        public class DoublyLinkedList {
            public DoublyLinkedListNode head;
            public void insertAtStart(int data)
            {
                DoublyLinkedListNode newNode = new DoublyLinkedListNode(data);
                if(head == null)
                {
                    head = newNode;
                }
                else
                {
                    newNode.setNext(head);
                    head.setPrev(newNode);
                    head = newNode;
                }
            }
           @Override
          public String toString() {
               return "DoublyLinkedList{" +
                       "head=" + head +
                       '}';
           }
            public void print()
            {
                DoublyLinkedListNode currentNode = head;
                while(currentNode != null)
                {
                    System.out.print(currentNode);
                    System.out.print("<=>");
                    currentNode = currentNode.getNext();
                }
                System.out.println("null");
            }
        }

Answer 1

此代码导致无限递归....

            @Override
        public String toString() {
            return "DoublyLinkedListNode{" +
                    "data=" + data +
                    ", next=" + next +
                    ", prev=" + prev +
                    '}';
        }

逐步浏览它。

• 将头节点转换为字符串时，它想要将下一个节点转换为字符串。

• 将第二个节点转换为字符串时，它希望将上一个节点（再次head节点）转换为字符串。

无限递归会导致无限嵌套的方法调用每个调用的堆栈，直到您用尽堆栈并获得堆栈溢出为止。