Java链表addFirst/removeFirst方法异常：需接收返回值才可生效

嗨，我来帮你理清这个问题的核心原因，还有对应的解决思路：

为什么直接调用addFirst/removeFirst不生效？ #

你的PureListString当前的实现逻辑，本质上是不可变链表的设计思路——每次调用addFirst或removeFirst，都会创建一个新的链表节点（或返回现有节点），但原对象的引用根本不会被修改。

拿你的addFirst代码举例：

public PureListString addFirst(String elt) {
    PureListString newCell = new PureListString(elt);
    PureListString tmp = this; // tmp指向原对象L
    tmp.size++; // 这里其实修改了原对象L的size
    newCell.tail = tmp;
    tmp = newCell; // 只是把局部变量tmp指向新节点，和原对象L没关系
    return tmp;
}

你在方法里修改的tmp只是方法内部的局部变量，原对象L的引用依然指向原来的头节点，所以直接调用L.addFirst("abc")后，L还是原来的链表，只有接收返回值才能拿到新增头节点后的新链表。

removeFirst的问题完全一致：你返回的是this.tail，但原对象L还是指向原来的头节点，并没有更新。

而addLast能正常工作，是因为你在方法里直接修改了原链表尾节点的tail引用，相当于直接修改了原对象的结构，所以不需要接收返回值（不过这个实现其实和你的addFirst/removeFirst设计不一致，后面会说）。

另外，你的代码还有个隐藏bug：addFirst里修改tmp.size++会改变原对象的size，但原对象只是新链表的一部分，这会导致原链表的size值完全错误。

两种修复方向，选哪个看你的需求 #

方向1：改成可变链表（调用方法直接修改原对象） #

如果你希望像普通ArrayList一样，直接调用L.addFirst()就修改原链表，那需要重构你的代码结构：

• 单独创建一个PureLinkedList类，用来维护整个链表的头节点、尾节点和总size
• 把当前的PureListString改成单纯的节点类（只存first、tail）

示例重构后的核心代码：

// 节点类
class PureListNode {
    String value;
    PureListNode next;

    public PureListNode(String value) {
        this.value = value;
        this.next = null;
    }
}

// 可变链表类
class PureLinkedList {
    private PureListNode head;
    private int size;

    public PureLinkedList(List<String> initialList) {
        // 初始化链表逻辑
        size = initialList.size();
        // ...
    }

    public void addFirst(String elt) {
        PureListNode newNode = new PureListNode(elt);
        newNode.next = head;
        head = newNode;
        size++;
    }

    public void removeFirst() {
        if (head == null) return;
        head = head.next;
        size--;
    }

    // 其他方法：get、contains等
}

这样修改后，直接调用L.addFirst("abc")就能修改原链表，不需要接收返回值。

方向2：保持不可变链表设计，修正实现逻辑 #

如果想保留当前“每个节点就是链表本身”的设计（不可变链表的典型模式），那需要修正addFirst和removeFirst的实现，确保原对象不被修改，每次操作返回新的链表：

修正后的addFirst：

public PureListString addFirst(String elt) {
    PureListString newCell = new PureListString(elt);
    newCell.tail = this;
    newCell.size = this.size + 1; // 新节点的size是原链表size+1，原对象size不动
    return newCell;
}

修正后的removeFirst：

public PureListString removeFirst() {
    if (this.isEmpty()){
        return EMPTY_LIST;
    }
    // 直接返回尾节点，尾节点的size已经是当前size-1（因为不可变，创建时就正确赋值）
    return this.tail;
}

同时，你的addLast也需要改成符合不可变链表的实现（不能修改原链表）：

public PureListString addLast(String elt) {
    if (this.isEmpty()) {
        return new PureListString(elt);
    }
    // 递归创建新的链表节点，原链表保持不变
    PureListString newTail = this.tail.addLast(elt);
    PureListString newHead = new PureListString(this.first);
    newHead.tail = newTail;
    newHead.size = this.size + 1;
    return newHead;
}

这种设计下，正确的用法必须接收返回值，因为原链表是不可变的：

// 正确用法
L = L.addFirst("abc");
System.out.println(L.get(0)); // 输出"abc"

总结 #

• 如果你要的是可变链表：重构代码，把链表和节点分开，让方法直接修改原对象的状态。
• 如果你要的是不可变链表：修正方法实现，不要修改原对象的属性，每次操作返回新的链表，并且必须接收返回值来更新引用。

内容的提问来源于stack exchange，提问作者idaoudi07