java - 如何从java中的链接列表中的节点检索对象的内容

Question

这个问题已经有答案了:

How do I print my Java object without getting "SomeType@2f92e0f4"? (14 个回答)

已关闭 3 年前。

我创建了一个包含字符串和整数的 Person 对象。我创建了一个 Node 类来接受泛型类型作为输入。当我调试时，我可以看到对象被创建和存储，但我的输出只是所述对象的内存地址。我尝试将对象解析为 toString() 中的字符串方法，但没有运气。我有预感，问题出在我声明通用数据类型的方式上。 这是我的代码:

类(class)人物

public class Person {
   //variables
   private String name;
   private int age;

   // default const.
   public Person() {
      name = " ";
      age = 0;
   }
   // overloaded constructor
   public Person(String name, int age) {
      this.name = name;
      this.age = age;
   }
   // methods
   public void setName(String name) {
      this.name = name;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String getName() {
      return name;
   }
   public int getAge() {
      return age;
   }
}

类节点

package LinkedList;


public class Node <T> {
   // added parameters for person object
   T p;

   Node nextNode;

   public Node () {

   }
   public Node (T p) {
      this.p = p;

   }

   // parse int data into string to simplify the unit test by not showing node memory locations
   @Override
   public String toString() {
      return p.toString();
   }
}

链表类

package LinkedList;

public class myLinkedList <T>{
   //Nodes
   Node head;
   Node tail;
   int size = 0;

   // Generic method
   public void add (T p){
      Node node = new Node(p);
      if(tail == null){
         head = node;        // if no previous tail the new node is the head
         tail = node;        // if no previous tail the new node is also the tail
      }else {
         tail.nextNode = node;  // adds a node to the end of the list
         tail = node;           // the newest node is set to the tail;
      }
      size ++;
   }

   // Generic search method
   public Node search (T p) {
      //empty list
      if (head == null)
         return null;

      // check if the first node is a match
      if (head.p == p)
         return head;

      // assign node as iterator
      Node node = head;

      // iterate through linked list
      while (node.nextNode != null) {
         // assign the next node as current node
         node = node.nextNode;
         // compare current node's data to data
         if (node.p == p)
            System.out.println(" object found");
         return node;
         //exit when the last node is reached

      }
      return null;
   }

   public Node findPreviousNode (T p) {
      // if the current node has no previous node (it's the head)
      if(head.p == p)
      return new Node();

      Node node = head;
      //go through list looking for desired node and return the one before it
      while(node.nextNode != null) {

         if(node.nextNode.p == p)
         return node;
         // if desired node is not found move onto next node
         node = node.nextNode;

      }
      // returns null for previous node if desired node doesn't exist
      return null;
   }

   public Node delete (T p){

      // node selected to delete, initializes as null for a placeholder
      Node nodeToReturn = null;

      //empty list nothing to return
      if(size == 0)
      return null;

      //list of only one node
      if(size == 1) {
         nodeToReturn = head;
         head = null;
         tail = null;
         size --;
         return nodeToReturn;
      }

      // find and delete last node
      Node nodePrev = findPreviousNode(p);

      if(nodePrev.p == null) {

         head = head.nextNode;
         size --;

      } else if(nodePrev != null) {
         if(tail.p == p) {
            nodePrev.nextNode = null;
            tail = nodePrev;
         } else {

            nodePrev.nextNode = nodePrev.nextNode.nextNode;
         }
         size --;
      }

      return null;

   }

   public void traverse() {
      // checks for empty list and prints out the first node
      if(head != null) {
         Node node = head;
         System.out.print(node);

         // moves from node to node printing until it reaches null as nextNode
         while(node.nextNode != null) {

            node = node.nextNode;
            System.out.print( "  " + node.toString());
         }
      }
   }
}

主类

import java.util.ArrayList;
import LinkedList.*;

public class main {
   public static void main(String[] args) {
      // implement linked list
      System.out.println("\n\n Object Linked list");
      myLinkedList peopleGroup = new myLinkedList();
      peopleGroup.add(new Person("robert", 23));
      System.out.println(peopleGroup.search("robert"));
      peopleGroup.add(mike);
      peopleGroup.add(marie);

      peopleGroup.traverse();
   }
}

输出:(我猜测，搜索函数返回 null 的原因与罪魁祸首相同)。

Object Linked list
null
Person@677327b6  Person@14ae5a5  Person@7f31245a
Process finished with exit code 0

Answer 1

您获得的输出不是内存地址，而是哈希值。

toString() 的默认实现是 ClassName@hashValue。

现在您正在重写 Node 类中的 toString() 来返回 Person.toString() 的值，该值仍然是默认实现.

因此，如果您现在在 Person 类中重写 toString()，那么就可以开始了。