java - 在Java中打印双向链表抛出异常(Stack Overflow Exception)

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 +
                    '}';
        }

逐步完成它。

• 当将头节点转换为字符串时，它希望将下一个节点转换为字符串。

• 当将第二个节点转换为字符串时，它希望将前一个节点(又是头节点)转换为字符串。

无限递归会导致无限嵌套的方法调用，每次调用都会增加堆栈，直到耗尽堆栈并出现堆栈溢出。