Java泛型链表类型不匹配错误解析与最佳实践

class ListNode <E> {
   private E val;
   private ListNode <E> next;

   public ListNode(E val, ListNode <E> next){
      this.val = val;
      this.next = next;
   }
   // ... 省略 getter 和 updateNext 方法
}

class LList2 <E> {
   private ListNode <E> front;
   private ListNode <E> rear;

   // ... 省略构造器、printWhile、printFor、addFirst 方法

   public void addLast(E obj){ // 注意：这里期望的是类型 E 的对象
      if(rear != null)
         rear.updateNext(new ListNode<E>(obj, null));
      else{
         rear = new ListNode<E>(obj, null);
         front = rear;
      }
   }
}

// 错误示例
LList2 <Integer> temp = new LList2 <> (list, rear);
temp.addLast(new ListNode<Integer> (-2, null)); // 编译错误：incompatible types

// 正确示例
LList2 <Integer> temp = new LList2 <> (list, rear);
temp.addLast(-2); // 直接传递 Integer 类型的值

class LList2 <E> {
    // ... 其他成员和方法

    public void printWhile() { // 改进后的打印方法
        StringBuilder sb = new StringBuilder("[");
        ListNode<E> current = front; // 使用临时变量遍历
        while (current != null) {
            sb.append(current.getVal());
            if (current.next != null) { // 检查是否还有下一个元素，避免末尾逗号
                sb.append(", ");
            }
            current = current.getNext();
        }
        sb.append("]");
        System.out.println(sb.toString());
    }

    // 可以在 ListNode 中添加一个 hasNext() 方法，使判断更清晰
    // public boolean hasNext() { return next != null; }
}

class ListNode <E> {
   private final E val; // 声明为 final
   private ListNode <E> next;

   // ... 构造器和方法
}

public class SingleLinkedListWorkSheetQ2Q3 {
    public static void main(String[] args) {
        // 初始化链表节点
        ListNode<Integer> rearNode = new ListNode<>(0, null); // 初始尾节点
        ListNode<Integer> list = new ListNode<>(1, rearNode); // 1 -> 0
        list = new ListNode<>(2, list); // 2 -> 1 -> 0
        list = new ListNode<>(3, list); // 3 -> 2 -> 1 -> 0

        // 创建 LList2 实例，front指向3，rear指向0
        LList2<Integer> temp = new LList2<>(list, rearNode);

        System.out.print("原始链表: ");
        temp.printWhile(); // 打印: [3, 2, 1, 0]

        // 正确调用 addLast 方法，添加 -2
        temp.addLast(-2);

        System.out.print("添加-2后链表: ");
        temp.printWhile(); // 打印: [3, 2, 1, 0, -2]
    }
}

class ListNode<E> {
    private final E val; // 值声明为final，增强不可变性
    private ListNode<E> next;

    public ListNode(E val, ListNode<E> next) {
        this.val = val;
        this.next = next;
    }

    public E getVal() {
        return val;
    }

    public ListNode<E> getNext() {
        return next;
    }

    public boolean hasNext() { // 辅助方法，判断是否有下一个节点
        return next != null;
    }

    public void updateNext(ListNode<E> node) {
        next = node;
    }
}

class LList2<E> {
    private ListNode<E> front;
    private ListNode<E> rear;

    public LList2(ListNode<E> front, ListNode<E> rear) {
        this.front = front;
        this.rear = rear;
    }

    public void printWhile() {
        StringBuilder sb = new StringBuilder("[");
        ListNode<E> current = front;
        while (current != null) {
            sb.append(current.getVal());
            if (current.hasNext()) { // 使用 hasNext() 判断
                sb.append(", ");
            }
            current = current.getNext();
        }
        sb.append("]");
        System.out.println(sb.toString());
    }

    public void addFirst(E obj) {
        front = new ListNode<>(obj, front);
        if (rear == null) { // 如果链表为空，则新节点既是头也是尾
            rear = front;
        }
    }

    public void addLast(E obj) {
        ListNode<E> newNode = new ListNode<>(obj, null); // 创建新节点
        if (rear != null) {
            rear.updateNext(newNode); // 更新原尾节点的next
            rear = newNode; // 更新rear指针指向新尾节点
        } else { // 链表为空时，新节点既是头也是尾
            front = newNode;
            rear = newNode;
        }
    }
}