Java LinkedList添加多个节点

Question

我的问题在我的main方法中，如何向链表中添加多个节点....我现在先从节点2和节点3开始..我以为我添加了这些节点，但是我意识到我并没有对这些节点和它们的值做任何事情，对吗？如何使用setData()和setNext()来添加所有这些节点？这有意义吗？

ListNode<String> node4 = new ListNode<String>("Fourth", null);
ListNode<String> node3 = new ListNode<String>("Third", node4);
ListNode<String> node2 = new ListNode<String>("Second", node3);
ListNode<String> first = new ListNode<String>("First", node2);

如果上面设置了值，如何将它们全部添加？

然后，我需要为每一项设置数据和下一步吗？(这似乎是多余的，因为我似乎在上面的构造函数中设置了每个节点的值。)

first.setData("first");
first.setNext(node2); 
node2.setData("Second");
node2.setNext(node2);
//.....

我正在尝试添加上述所有节点，以便通过添加新节点来测试我的addLast（）方法。但是，当我在main中调用我的addLast（）方法时，正如您在下面看到的那样，唯一打印的是我添加的addLast（）值（如果我调用addFirst（），则首先打印）。

测试类

public class LinkedListDriver
{

    public static void main(String[] args) {
        //List<String> list = new LinkedList<String>();                   //comment out this line to test your code
        SinglyLinkedList<String> list = new SinglyLinkedList<String>(); //remove comment to test your code

        ListNode<String> node4 = new ListNode<String>("Fourth", null);
        ListNode<String> node3 = new ListNode<String>("Third", node4);
        ListNode<String> node2 = new ListNode<String>("Second", node3);
        ListNode<String> first = new ListNode<String>("First", node2);

        ListNode value = new ListNode("First", new ListNode("Second", new ListNode("Third", null)));

        //I've been messing around with this but 
        list.addFirst(first.getData());
        list.addFirst("Second");

        list.addLast("Fifth");
        list.printList();
    }
}

我没有添加我的其他两个类，因为我认为这是不相关的，但如果你想看，让我知道。我很新，这只是我的第二堂课，它是在线的，是很差的构造类，请很好lol

SinglyLinkedList类

//This class implements a very simple singly-linked list of Objects
public class SinglyLinkedList<E>
{
    ListNode<E> first; // first element

    public SinglyLinkedList() {
        first = null;
    }

    public E getFirst() {
        if (first == null) {
            throw new NoSuchElementException();
        } else
            return first.getData();
    }

    public void addFirst(E value) {
        first = new ListNode<E>(value, first);
    }

    // Methods below implemented by you. Note: while writing methods, keep in mind
    // that you might be able to call other methods in this class to help you - you
    // don't always need to start from scratch(but you'll have to recognize when)

    public void addLast(E value) {
        ListNode<E> temp = first;
        //If list is empty make new node the first node.
        if (temp == null) {
            first = new ListNode <E>(value, null);
            first.setNext(null);
        }//Otherwise loop to end of list and add new node.
        else {
            while (temp.getNext() != null) {
                temp = temp.getNext();
            }
            temp.setNext(new ListNode<E>(value, null));
        }
    }//end addLast

    // throws an exception - you decide when and which one

    public E getLast() {
        ListNode<E> temp = first;
        if (temp == null) {
            throw new NullPointerException("There are no elements in this list to get.");
        } else {
            while (temp.getNext() != null) {
                temp = temp.getNext();
            }
            return temp.getData();
        }
    }

    // throws an exception - you decide when and which one

    public E removeFirst() {
        if (first == null) {
            throw new NullPointerException("There are no elements in this list to remove.");
        }
        ListNode<E> tempRemove = first;
        return null; //just so it'll compile
    }

    // throws an exception - you decide when and which one

    public E removeLast() {
        return null; //just so it'll compile
    }

    // return the number of elements in the list

    public int size() {
        return 0; //just so it'll compile
    }

    // return true if o is in this list, otherwise false

    public boolean contains(E obj) {
        return true; //just so it'll compile
    }

    public void printList(java.io.PrintStream out) {
        if (first == null) {
            System.out.println("The list is empty");
        }
        ListNode<E> current = first;
        while (current != null) {
            System.out.println(current.toString());
            current = current.getNext();
        }
    }

    public String toString() {
        String s = "[";
        ListNode<E> current = first;
        //write code to traverse the list, adding each object on its own line
        while (current.getNext() != null) {
            current = current.getNext();
        }

        s += "]";
        return s;
    }

    // OPTIONAL: just for fun...and a challenge

    public void reverse() {
    }
}

ListNode类是您的基本getNext setNext，getData setData....

Answer 1

你想做什么？如果您试图填充链表，您需要做的就是不断调用list.addLast，它将接受一个参数(您正在添加的新节点中的数据)，并处理创建新节点并将其放在列表的后面。

我假设您不需要在主节点中创建任何节点，因为它们通常完全由 linklist 类处理。

Answer 2

几点，主要是总结评论：

您根本不应该使用main（）中的ListNodeobjects-这应该是singleLinkedList类的工作ListNode甚至不需要对代码的其余部分可见，它可以是SingleyLinkedList中的嵌套类。您应该只与singleLinkedList交换数据对象（本例中为字符串）。

例如，如果您想测试addLast（）方法，您可以从一个空列表开始并重复调用list.addLast（），正如Shane在他的答案中提到的那样。这样，您将确保它在列表为空和非空时都有效。

SinglyLinkedList<String> list = new SinglyLinkedList<String>();
list.addLast("first");
list.addLast("second");
list.addLast("third");
list.printList(System.out);

至于在一次调用中添加多个节点——这个链表没有这样做的方法。例如，您可以添加一个方法来添加一个数组的所有元素，但是您可以只顺序调用< code>addLast()来获得相同的效果。如果您想从测试其他方法的一些基本数据开始，您可以在主类中创建一些helper方法来以这种方式填充列表。

附带说明：如果printList（）将java.io.PrintStream作为参数，则应该使用它而不是System.out

out.println(...)

代替

System.out.println(...)

此外，最好抛出 NoSuchElement 例外，而不是空点例外，以指示请求的元素不存在。

如果你想要一种方便的方式来填充列表，你可以在你的主类中有这样的东西：

static <E> void addToList(SinglyLinkedList<E> list, E... values) {
    for (E value : values) {
        list.addLast(value);
    }
}

像这样使用它:

SinglyLinkedList<String> list = new SinglyLinkedList<String>();
addToList(list, "first", "second", "third");