Java 字符串类不能强制转换为节点类

我有一个家庭作业，要重构一些代码以使用泛型。我觉得我在课堂上这样做是正确的。这是我的

public class Node<T> {

    private T content;
    private T next;

    public Node(T content, T next) {
        this.content = content;
        this.next = next;
    }

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }

    public T getNext() { return next; }

    public void setNext(T next) {
        this.next = next;
    }
}

公共类节点{
私有内容；
私人T next；
公共节点（T content，T next）{
this.content=内容；
this.next=next；
}
公共T getContent（）{
返回内容；
}
公共内容（T内容）{
this.content=内容；
}
public T getNext（）{return next；}
公共无效设置下一个（T下一个）{
this.next=next；
}
}

公共类链接列表{
专用节点头；
公共链接列表（）{
head=null；
}
公共无效添加优先（T内容）{
节点ptr=头部；
head=新节点（内容，ptr）；
}
公共void addLast（T内容）{
最后一个节点=新节点（内容，空）；
if（head==null）{
头=最后一个；
}否则{
节点ptr=新节点（内容、头）；
while（ptr.getNext（）！=null）{
ptr=ptr.getNext（）；
}
ptr.setNext（最后一个）；
}
}

在实例化时，我得到一个ClassCastException错误：

“线程“main”中的异常“java.lang.ClassCastException:无法将类java.lang.String转换为类edu.cscc.Node（java.lang.String位于加载程序“bootstrap”的模块java.base中；edu.cscc.Node位于加载程序“app”的未命名模块中）”

下面是我在主类中得到的导致错误的内容

public class Main {

    public static void main(String[] args) {
        list1();
        list2();
    }

    // Use linked list with Strings
    public static void list1() {
        LinkedList<String> llist = new LinkedList<String>();
        llist.addFirst("one");
        llist.addLast("two");
        llist.addLast("three");
        llist.addFirst("zero");
        llist.addLast("xxxx");
        llist.addFirst("yyyyy");
        llist.deleteLast();
        llist.deleteFirst();
        System.out.println(llist);
        llist.deleteFirst();
        llist.deleteLast();
        llist.deleteFirst();
        llist.deleteLast();
        System.out.println(llist);
    }

    // Use linked list with Integers
    public static void list2() {
        LinkedList<Integer> llist = new LinkedList<Integer>();
        llist.addFirst(1);
        llist.addLast(2);
        llist.addLast(3);
        llist.addFirst(0);
        llist.addLast(142);
        llist.addFirst(-97);
        llist.deleteLast();
        llist.deleteFirst();
        System.out.println(llist);
        llist.deleteFirst();
        llist.deleteLast();
        llist.deleteFirst();
        llist.deleteLast();
        System.out.println(llist);
    }
}

公共类主{
公共静态void main（字符串[]args）{
列表1（）；
列表2（）；
}
//使用带字符串的链表
公共静态无效列表1（）{
LinkedList llist=新LinkedList（）；
Allist.addFirst（“一”）；
添加最后一个（“两个”）；
第三名（“三名”）；
Allist.addFirst（“零”）；
llist.addLast（“xxxx”）；
llist.addFirst（“yyyy”）；
deletellast（）；
deleteFirst（）；
System.out.println（llist）；
deleteFirst（）；
deletellast（）；
deleteFirst（）；
deletellast（）；
System.out.println（llist）；
}
//使用带整数的链表
公共静态无效列表2（）{
LinkedList llist=新LinkedList（）；
第一组（1）；
alist.addLast（2）；
alist.addLast（3）；
alist.addFirst（0）；
李斯特·艾德拉斯特（142）；
利斯特。阿德菲斯特（-97）；
deletellast（）；
deleteFirst（）；
System.out.println（llist）；
deleteFirst（）；
deletellast（）；
deleteFirst（）；
deletellast（）；
System.out.println（llist）；
}
}

---

有人能指出是什么导致了这种情况吗？

我认为您在类中弄乱了一些类型。您可能应该有如下内容：

public class Node<T> {
    private final T content;
    private Node<T> next;

    public Node(T content, Node<T> next) {
        this.content = content;
        this.next = next;
    }

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }

    public Node<T> getNext() { 
       return next; 
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }
}

public class LinkedList<T> {
    private Node<T> head;

    public LinkedList() {
        head = null;
    }

    public void addFirst(T content) {
        head = new Node<>(content, head);
    }

    public void addLast(T content) {
        Node<T> last = new Node<>(content, null);
        if (head == null) {
            head = last;
        } else {
            Node<T> ptr = head;
            while (ptr.getNext() != null) {
                ptr = ptr.getNext();
            }
            ptr.setNext(last);
        }
    }
}

公共类节点{
私人最终T内容；
私有节点下一步；
公共节点（T内容，节点下一个）{
this.content=内容；
this.next=next；
}
公共T getContent（）{
返回内容；
}
公共内容（T内容）{
this.content=内容；
}
公共节点getNext（）{
下一步返回；
}
公共void setNext（节点next）{
this.next=next；
}
}
公共类链接列表{
专用节点头；
公共链接列表（）{
head=null；
}
公共无效添加优先（T内容）{
头部=新节点（内容，头部）；
}
公共void addLast（T内容）{
最后一个节点=新节点（内容，空）；
if（head==null）{
头=最后一个；
}否则{
节点ptr=头部；
while（ptr.getNext（）！=null）{
ptr=ptr.getNext（）；
}
ptr.setNext（最后一个）；
}
}
}

在

节点

中，您的

下一个

变量的类型错误：

public class Node<T> {

private T content;
private Node<T> next; // this is a reference to the next node

public Node(T content, Node<T> next) { // next is a Node<T>
    this.content = content;
    this.next = next;
}

...

public Node<T> getNext() { return next; }

public void setNext(Node<T> next) {
    this.next = next;
}

当列表中至少有一个项目时，

addLast

的逻辑似乎很奇怪。您应该找到列表中的最后一个项目，然后在其后面添加一个节点

Node<T> lastItem = head;
while(lastItem.getNext() != null) {
    lastItem = lastItem.getNext();
}
lastItem.setNext(new Node(content, last););

节点lastItem=头；
while（lastItem.getNext（）！=null）{
lastItem=lastItem.getNext（）；
}
setNext（新节点（content，last）；）；

我们可以查看完整的LinkedList类吗？但是即使我注释掉了您忽略的函数，我也不会得到任何错误。谢谢，这对我很有帮助。

public void addFirst(T content) {
    Node<T> ptr = head;
    head = new Node<T>(content, ptr);
}

Node<T> lastItem = head;
while(lastItem.getNext() != null) {
    lastItem = lastItem.getNext();
}
lastItem.setNext(new Node(content, last););