Java链表反转方法导致OutOfMemoryError的深入解析与正确实现

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

    while (p2 != null){
        Node temp = p2.next;
        p2.next = p1; // 关键问题所在：p2的next指向p1
        p1 = p2;
        p2 = temp;
    }

    this.head = p1;
}

import java.util.ArrayList;

class Node {
    public int val;
    public Node next;

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

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

    // setVal和setNext方法应为public或default，以便在MyCodeLink中访问
    // 但在链表反转的常见实现中，直接访问字段更常见
    // 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();
    }

    public void reversal() {
        Node previous = null;
        Node current = this.head;

        while (current != null) {
            Node nextTemp = current.next; // 暂存下一个节点
            current.next = previous;     // 反转当前节点的next指针
            previous = current;          // previous向前移动到当前节点
            current = nextTemp;          // current向前移动到下一个节点
        }
        this.head = previous; // 更新头节点为原链表的尾节点（反转后的头节点）
    }

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

        System.out.println("初始链表 size: " + myCodeLink.getSize());
        System.out.println("初始链表: " + myCodeLink); // 输出: 8

        myCodeLink.insertToHead(6);
        System.out.println("插入头部后 size: " + myCodeLink.getSize());
        System.out.println("插入头部后: " + myCodeLink); // 输出: 6    8

        myCodeLink.insert(1, 7);
        System.out.println("插入中间后 size: " + myCodeLink.getSize());
        System.out.println("插入中间后: " + myCodeLink); // 输出: 6    7   8

        myCodeLink.insertToLast(9);
        System.out.println("插入尾部后 size: " + myCodeLink.getSize());
        System.out.println("插入尾部后: " + myCodeLink); // 输出: 6    7   8   9

        System.out.println("\n执行反转操作...");
        myCodeLink.reversal();
        System.out.println("反转后链表 size: " + myCodeLink.getSize());
        System.out.println("反转后链表: " + myCodeLink); // 输出: 9    8   7   6
    }
}

初始链表 size: 1
初始链表: 8 
插入头部后 size: 2
插入头部后: 6    8   
插入中间后 size: 3
插入中间后: 6    7   8   
插入尾部后 size: 4
插入尾部后: 6    7   8   9   

执行反转操作...
反转后链表 size: 4
反转后链表: 9    8   7   6