Java单向链表反转错误导致OutOfMemoryError的解析与正确实现

public void reversal(){
    Node p1 = this.head;
    Node p2 = p1.next;

    while (p2 != null){
        Node temp = p2.next;
        p2.next = p1; // 错误点：这里可能创建循环引用
        p1 = p2;
        p2 = temp;
    }

    this.head = p1;
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.base/java.util.Arrays.copyOf(Arrays.java:3537)
    at java.base/java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:228)
    at java.base/java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:829)
    at java.base/java.lang.StringBuilder.append(StringBuilder.java:253)
    at com.company.MyCodeLink.toString(MyCodeLink.java:74) // 异常发生在这里
    // ... 其他堆栈信息

public void reversal(){
    Node current = this.head; // 当前正在处理的节点
    Node previous = null;    // 当前节点的前一个节点，初始为null

    while (current != null){
        Node nextTemp = current.next; // 1. 保存下一个节点，防止断链
        current.next = previous;      // 2. 将当前节点的next指针指向前一个节点，实现反转
        previous = current;           // 3. previous向前移动，成为下一个迭代的“前一个节点”
        current = nextTemp;           // 4. current向前移动，处理下一个节点
    }

    this.head = previous; // 循环结束后，previous指向原链表的最后一个节点，它现在是新链表的头
}

package com.company;

import java.util.ArrayList;

class Node {
    public Node(int val, Node next) {
        this.val = val;
        this.next = next;
    }

    public Node(int val) {
        this(val, null);
    }

    int val;
    Node next;

    // 实际上，为了封装性，这些setter方法应在LinkedList类中操作，
    // 或者设计为package-private，但此处为简化示例保留。
    // private void setVal(int newVal){
    //     this.val = newVal;
    // }
    //
    // private void setNext(Node newNextNode){
    //     this.next = newNextNode;
    // }
}

public class MyCodeLink {
    private Node head;
    private int size;

    public MyCodeLink(int val) {
        this.head = new Node(val, null);
        this.size = 1;
    }

    public void insert(int index, int val) {
        if (index < 0 || index > this.getSize()) {
            throw new IndexOutOfBoundsException("index must >= 0 and <= size");
        }
        if (index == 0) {
            this.head = new Node(val, head);
            this.size++;
            return;
        }

        Node cur = head;
        for (int i = 0; i < index - 1; i++) {
            cur = cur.next;
        }

        Node node = new Node(val, cur.next);
        cur.next = node;
        this.size++;
    }

    public void insertToHead(int val) {
        insert(0, val);
    }

    public void insertToLast(int val) {
        insert(this.getSize(), val);
    }

    public int getSize() {
        return this.size;
    }

    public Node getHead() {
        return head;
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Node cur = head;
        while (cur != null) {
            s.append(cur.val).append("\t");
            cur = cur.next;
        }
        return s.toString();
    }

    /**
     * 正确的链表反转方法
     * 使用迭代法，通过三个指针 (previous, current, nextTemp) 完成反转
     */
    public void reversal() {
        Node current = this.head;
        Node previous = null;

        while (current != null) {
            Node nextTemp = current.next; // 1. 保存下一个节点
            current.next = previous;      // 2. 反转当前节点的next指针
            previous = current;           // 3. previous指针向前移动
            current = nextTemp;           // 4. current指针向前移动
        }

        this.head = previous; // 更新链表头为原链表的最后一个节点
    }

    public static void main(String[] args) {
        MyCodeLink myCodeLink = new MyCodeLink(8);

        System.out.println("Initial size: " + myCodeLink.getSize());
        System.out.println("Initial list: " + myCodeLink);

        myCodeLink.insertToHead(6);
        System.out.println("After insertToHead(6), size: " + myCodeLink.getSize());
        System.out.println("List: " + myCodeLink);

        myCodeLink.insert(1, 7);
        System.out.println("After insert(1, 7), size: " + myCodeLink.getSize());
        System.out.println("List: " + myCodeLink);

        myCodeLink.insertToLast(9);
        System.out.println("After insertToLast(9), size: " + myCodeLink.getSize());
        System.out.println("List: " + myCodeLink); // 此时链表应为 6 7 8 9

        System.out.println("\n--- Performing reversal ---");
        myCodeLink.reversal();
        System.out.println("After reversal, size: " + myCodeLink.getSize());
        System.out.println("Reversed list: " + myCodeLink); // 此时链表应为 9 8 7 6
    }
}