Question

public void printList( ){
    Node<E> p ;
    System.out.printf( ” [ ” ) ;
    for ( p=head.next ; p != null ; p=p.next )
        System.out.print( p.element ) ;
    System.out.printf( ” ] ” ) ;
}

public void addLast (E e){
    Node<E> p = head;   // <--- data type Node<E>, var name = p, but what is head type?
    while ( p.next != null )
        p = p.next ;
    p.next = new Node<E>(e , null ) ;
}

泛型示例：

public class Box {
private Object object;

public void set(Object object) { this.object = object; }
public Object get() { return object; }

}

使用泛型：

// T stands for "Type"
public class Box<T> {
    private T t; 

    public void set(T t) { 
        this.t = t;
    }
    public T get() { 
        return t;
    }
}

我对链表如何直观地工作有一个大概的想法，但我无法在代码中看到它。

我知道你有元素和对下一个节点的引用。在上面的代码中，“。”是怎么回事。运算符在遍历列表时工作，直到达到null？

我相信'next'是一个参考变量。什么时候它p = p.next，它在代码/计算机中如何工作？

在一个不相关的说明，节点？而不是节点（E）？区别？在上面的例子中，似乎'对象'被't'取代，我看不到优势。 ; S

非常感谢任何帮助，提前谢谢！

Answer 1

在上面的代码中，只要head.next不等于null，p将被设置为列表中的下一个“链接”。这将继续下去。 p.next返回对下一个链接的引用，然后将其设置为p。该参考链将继续。

Node<E>是一种泛型类型，它允许类的用户传递要包含的节点的类型。与仅使用演员表相比，这可以提供更大的类型安全性。

Answer 2

假设您的Node班级属于以下类别：

class Node<T>{
    Node<T> next;
    T element;
}

现在，对“Node”类的任何引用都可以访问它的两个属性。 .运算符用于访问属性。

设置p = p.next时，它只是内部指针的移动。

Answer 3

将LinkedList视为链接节点列表可能会有所帮助。每个节点将保存对下一个节点的引用（如果存在）。我不确定它是否会有所帮助，但是当我不得不在学校完成这项任务时，我发现通过API并尝试使用它非常有帮助。

使用泛型节点将是Object类型的节点，其中Node将是特定类型的节点。例如，LinkedList将保存字符串。 This，可能有助于更好地理解泛型如何工作。

以下是使用泛型的简单示例：

Class Box<E>{
    private E variable;

    public E get(){
        return variable;
    }

    public void set(E variable){
        this.variable=variable;
    }

    public static void main(String[] args){
        Box<String> example=new Box<String>();
        example.set("test");
        System.out.println(example.get());

        Box<Integer> example2=new Box<Integer>();
        example2.set(1);
        //example2.set("test");will not work because it is types as an Integer
        System.out.println(example2.get()+1);
    }
}

链接列表直觉

3 个答案: