为什么node.next转到下一个节点

Question

我对编程有点陌生，目前正在研究链接列表。我在网上某个地方得到了这个代码。public class Node {    Node next;    int data;    public Node(int data)     {        this.data=data;    }    public class LinkedList    {            Node head;        public void delete(int data)         {                Node current=head;            while (current.next!=null)            {                 if (current.next.data==data)                {                    current.next= current.next.next;                }             }         }     }}我不明白的是为什么node.next指向下一个节点？在 Node 类中，接下来是数据类型 Node。Node 类中没有 next 方法，但在LinkedList类中调用时current.next它假定引用下一个节点。

Answer 1

考虑这里的代码，我在 main 方法中添加的每个节点都是 Node 类的一个对象，并且该类包含 Node next ，它是对下一个节点的引用。例如，第一个具有 value 的节点22包含对具有 value 的第二个节点的引用2。例如，如果只添加了一个节点，则下一个节点将引用 null，因为没有第二个节点。在每个节点对象中，节点下一个引用为您提供下一个节点。但我强烈建议你阅读 java 中的引用，因为你在这里错过了一个基本概念。

import java.util.Objects;

class LinkedList<T> {

    private class Node<E> {

        Node<E> next; 

        E val;

        Node(E val) {

            this.val = val;

        }

    }

    private Node<T> head;

    void add(T val) {

        Node<T> node = new Node<>(val);

        if (head == null) {

            head = node;

        } else {

            Node<T> p = head;

            while (p.next != null) {

                p = p.next;

            }

            p.next = node;

        }

    }

    void show() {

        if (head == null)

            return;

        Node<T> p = Objects.requireNonNull(head);

        while (p.next != null) {

            System.out.print(p.val + " ");

            p = p.next;

        }

        System.out.println(p.val);

    }

}

class Main {

    public static void main(String... args) {

        LinkedList<Integer> ll = new LinkedList<>();

        ll.add(22);

        ll.add(2);

        ll.add(4);

        ll.add(32);

        ll.add(3);

        ll.add(1);

        ll.add(44);

        ll.show();

    }

}

Answer 2

假设你有一个 Node n。Node 的类定义包含一个成员变量声明，Node next;这意味着 Node 类及其子类的每个实例都会有一个 typeNode和 name的成员变量next。因此，没有名为 的方法next。相反，它是一个被访问的变量。这就是该语句current.next= current.next.next;合法的原因 - 您不能写入函数调用的结果（通常）。但是，您可以写入成员变量（或从函数调用返回的 xyz 类实例的成员变量）。