如何在链接堆栈的实现中编写toString和peek函数？

如何解决如何在链接堆栈的实现中编写toString和peek函数？

我在每个代码块下面都有注释。

public class LinearNode<T>
{
    private LinearNode<T> next;
    private T element;
 
    /**
     * Creates an empty node.
     */
    public LinearNode()
    {
        next = null;
        element = null;
    }
 
    /**
     * Creates a node storing the specified element.
     * @param elem element to be stored
     */
    public LinearNode(T elem)
    {
        next = null;
        element = elem;
    }
 
    /**
     * Returns the node that follows this one.
     * @return reference to next node
     */
    public LinearNode<T> getNext()
    {
        return next;
    }
 
    /**
     * Sets the node that follows this one.
     * @param node node to follow this one
     */
    public void setNext(LinearNode<T> node)
    {
        next = node;
    }
 
    /**
     * Returns the element stored in this node.
     * @return element stored at the node
     */
    public T getElement()
    {
        return element;
    }
 
    /**
     * Sets the element stored in this node.
     * @param elem element to be stored at this node
     */
    public void setElement(T elem)
    {
        element = elem;
    }
}

以上是节点本身的实际类，在该类中您具有获取器和设置器，用于获取和设置其属性的节点的特定特征。每个节点都有一个下一个“指针”，并具有一个将元素放入其中的构造函数。

import java.util.Iterator;

/**
 * Represents a linked implementation of a stack.
 */
public class LinkedStack<T> 
{
    private int count;  
    private LinearNode<T> top; 

    /**
     * Creates an empty stack.
     */
    public LinkedStack()
    {
        count = 0;
        top = null;
    }

    /**
     * Adds the specified element to the top of this stack.
     * @param element element to be pushed on stack
     */
    public void push(T element)
    {
        LinearNode<T> temp = new LinearNode<T>(element);

        temp.setNext(top);
        top = temp;
        count++;
    }

    /**
     * Removes the element at the top of this stack and returns a
     * reference to it. 
     * @return element from top of stack
     * @throws EmptyCollectionException if the stack is empty
     */
    public T pop() throws EmptyCollectionException
    {
        if (isEmpty())
            throw new EmptyCollectionException("stack");

        T result = top.getElement();
        top = top.getNext();
        count--;

        return result;
    }

    /**
     * Returns a reference to the element at the top of this stack.
     * The element is not removed from the stack.  
     * @return element on top of stack
     * @throws EmptyCollectionException if the stack is empty  
     */
    public T peek() throws EmptyCollectionException
    {
        if(isEmpty()) { 
            throw new EmptyCollectionException("stack");
        }
    
        T node =top.getElement();
        return node;
    }
    /**
     * Returns true if this stack is empty and false otherwise. 
     * @return true if stack is empty
     */
    public boolean isEmpty()
    {
        if(count==0) {return true;}
        else {

            return false;}
    }

    /**
     * Returns the number of elements in this stack.
     * @return number of elements in the stack
     */
    public int size()
    {
        
        return count;
    }

    /**
     * Returns a string representation of this stack. 
     * @return string representation of the stack
     */
    public String toString()
    {
        
    
        
        //not exactly sure
        


    }
}

这是LinkedStack类，其中在前一个代码块中实现LinearNode类。它本质上是使用上述push(...)方法将每个节点链接在一起形成链接列表。我的peek()和toString(...)方法遇到问题。它提供了一种有效地将节点链接在一起的方法，而与节点的类型无关。

我的实现如下所示，其中我使用一个Scanner接收用户输入，然后使用另一个Scanner接收用户输入的字符串，并将每个单词放入创建的 LinearNode 中。我使用 LinkedStack 中的各种方法来实现和链接节点。我的目标是要在LinkedStack类中使用我的所有方法。 下面是我的实现

import java.util.*;
public class Sentence {

    public static void main(String[] args) {
        String sentence;
//Takes in user input
        Scanner userInput= new Scanner(system.in);

        System.out.println("Please type in sentence.");

sentence=userInput.nextLine();


userInput.close();

//Instantiates a new LinkedStack which takes in type of LinearNode
LinkedStack <LinearNode> Stack=new LinkedStack <LinearNode>();

//Scanner that grabs each individual workd from string
Scanner checker = new Scanner(sentence);
while(checker.hasNext()) {
    String x =checker.next();
    LinearNode<String> words=new LinearNode<String>(x);
    Stack.push(words);  //pushes the new created node with the individual word ```x``` onto the ```Stack```  
    
}
//other methods 
System.out.println(Stack.size());
System.out.println("Emptiness: "+Stack.isEmpty());
System.out.println("we peek on "+Stack.peek());// not sure how to get the actual node

System.out.println("The to string method is: "+Stack.toString());//want this to work correctly
        

System.out.println("we pop "+Stack.pop());

System.out.println(Stack.size());


checker.close();






    }

}

输出为：

Please type in sentence.
Hello world  
2 
Emptiness: false
we peek on LinearNode@6f496d9f

we pop LinearNode@6f496d9f
1

单个整数是size（）方法。

问题： 当我使用peek()方法时，我似乎正在获取我想返回实际节点的地址。 而且我无法弄清楚如何从LinkedStack的节点中获取对象以使用我的toString()方法进行打印。

解决方法

它提供了一种有效的方法

无论您做什么，这些事情在现代硬件上都是无效的，所以请不要介意:)-但这不是您的问题，所以让我们继续吧。

您的LinearNode和LinearStack类工作得很好，但请注意，LinearNode完全是一项内部工作：LinearStack对其进行查询。实际上，您应该使LinearNode成为非公开的，以突出这一事实。它在这里为LinearStack带来好处，而其他代码对em的影响则为零。例如，如果有人引用了堆栈中的LinearNode，则可以调用.setNext并中断您的列表。例如，这不会神奇地更新该节点所在的任何列表中的count，或者我可能有多个堆栈对象，每个对象在某个地方都具有相同的节点，如果您开始弹出，则会造成真正的怪异效果放在一个堆栈中（因为那样会与另一个堆栈混淆……而无需更新计数）。

这就是您在这里所做的所有事情：您有一堆LinearNode对象。堆栈是通用的，它可以存储您想要存储的任何内容，因此它可以准确地执行您所命令的内容，并且内部具有LinearNode<LinearNode<String>>。是的，这是节点的节点。不是你想要的。

所以，不要：

String x = checker.next();
LinearNode<String> words = new LinearNode<String>(x);
stack.push(words);

执行以下代码：第二行创建一个linearnode，然后调用堆栈推入。看一下该代码：首先是什么？创建一个LinearNode对象。那是不对的-1个推送的元素应该意味着1个创建的节点对象。

执行：

String x = checker.next();
stack.push(x);

此外，您已声明堆栈为“节点堆栈”。那不是你想要的。您希望它是一个“字符串堆栈”。同样，LinearNode在您的主类中绝对不应该存在，对于所有代码都应该是不可见且不存在的。.除了LinearStack需要它起作用之外。将其声明为LinearStack<String>。