如何在不获取“SomeType@2f92e0f4”的情况下打印我的 Java 对象？

How do I print my Java object without getting "SomeType@2f92e0f4"?

提问by Duncan Jones

I have a class defined as follows:

我有一个类定义如下：

public class Person {
  private String name;

  // constructor and getter/setter omitted
}

I tried to print an instance of my class:

我试图打印我的类的一个实例：

System.out.println(myPerson);

but I got the following output: com.foo.Person@2f92e0f4.

但我得到了以下的输出：com.foo.Person@2f92e0f4。

A similar thing happened when I tried to print an array of Personobjects:

当我尝试打印一组Person对象时发生了类似的事情：

Person[] people = //...
System.out.println(people); 

I got the output: [Lcom.foo.Person;@28a418fc

我得到了输出： [Lcom.foo.Person;@28a418fc

What does this output mean? How do I change this output so it contains the name of my person? And how do I print collections of my objects?

这个输出是什么意思？如何更改此输出以使其包含我的人名？以及如何打印我的对象的集合？

_{Note: this is intended as a canonical Q&A about this subject.}

_{注意：这是关于这个主题的规范问答。}

采纳答案by Duncan Jones

Background

背景

All Java objects have a toString()method, which is invoked when you try and print the object.

所有 Java 对象都有一个toString()方法，当您尝试打印对象时会调用该方法。

System.out.println(myObject);  // invokes myObject.toString()

This method is defined in the Objectclass (the superclass of all Java objects). The Object.toString()method returns a fairly ugly looking string, composed of the name of the class, an @symbol and the hashcodeof the object in hexadecimal. The code for this looks like:

该方法在Object类（所有Java 对象的超类）中定义。该Object.toString()方法返回一个相当难看的字符串，由类名、@符号和十六进制对象的哈希码组成。代码如下：

// Code of Object.toString()
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

A result such as com.foo.MyType@2f92e0f4can therefore be explained as:

因此，这样的结果com.foo.MyType@2f92e0f4可以解释为：

• com.foo.MyType- the name of the class, i.e. the class is MyTypein the package com.foo.
• @- joins the string together
• 2f92e0f4the hashcode of the object.

• com.foo.MyType- 类的名称，即类MyType在包中com.foo。
• @- 将字符串连接在一起
• 2f92e0f4对象的哈希码。

The name of array classes look a little different, which is explained well in the Javadocs for Class.getName(). For instance, [Ljava.lang.Stringmeans:

数组类的名称看起来有点不同，这在 Javadocs for Class.getName(). 例如，[Ljava.lang.String意味着：

• [- an single-dimensional array (as opposed to [[or [[[etc.)
• L- the array contains a class or interface
• java.lang.String- the type of objects in the array

• [- 一维数组（与[[或[[[等相反）
• L- 数组包含一个类或接口
• java.lang.String- 数组中对象的类型

---

---

Customizing the Output

自定义输出

To print something different when you call System.out.println(myObject), you must overridethe toString()method in your own class. Here's a simple example:

要在调用 时打印不同的内容System.out.println(myObject)，您必须在您自己的类中覆盖该toString()方法。这是一个简单的例子：

public class Person {

  private String name;

  // constructors and other methods omitted

  @Override
  public String toString() {
    return name;
  }
}

Now if we print a Person, we see their name rather than com.foo.Person@12345678.

现在，如果我们打印 a Person，我们会看到他们的名字而不是com.foo.Person@12345678。

Bear in mind that toString()is just oneway for an object to be converted to a string. Typically this output should fully describe your object in a clear and concise manner. A better toString()for our Personclass might be:

请记住，这toString()只是将对象转换为字符串的一种方式。通常，此输出应以清晰简洁的方式完整描述您的对象。toString()对我们Person班级更好的可能是：

@Override
public String toString() {
  return getClass().getSimpleName() + "[name=" + name + "]";
}

Which would print, e.g., Person[name=Henry]. That's a really useful piece of data for debugging/testing.

这将打印，例如，Person[name=Henry]。这是一个非常有用的调试/测试数据。

If you want to focus on just one aspect of your object or include a lot of jazzy formatting, you might be better to define a separate method instead, e.g. String toElegantReport() {...}.

如果您只想关注对象的一个​​方面或包含大量爵士格式，则最好定义一个单独的方法，例如String toElegantReport() {...}.

---

---

Auto-generating the Output

自动生成输出

Many IDEsoffer support for auto-generating a toString()method, based on the fields in the class. See docs for Eclipseand IntelliJ, for example.

许多IDE支持toString()基于类中的字段自动生成方法。例如，请参阅Eclipse和IntelliJ 的文档。

Several popular Java libraries offer this feature as well. Some examples include:

一些流行的 Java 库也提供此功能。一些例子包括：

• ToStringBuilderfrom Apache Commons Lang

• MoreObjects.ToStringHelperfrom Google Guava

• @ToStringannotation from Project Lombok

• ToStringBuilder来自Apache Commons Lang

• MoreObjects.ToStringHelper来自谷歌番石榴

• @ToString来自Project Lombok 的注释

---

---

Printing groups of objects

打印对象组

So you've created a nice toString()for your class. What happens if that class is placed into an array or a collection?

所以你已经toString()为你的班级创造了一个很好的。如果将该类放入数组或集合中会发生什么？

Arrays

数组

If you have an array of objects, you can call Arrays.toString()to produce a simple representation of the contents of the array. For instance, consider this array of Personobjects:

如果您有一个对象数组，则可以调用Arrays.toString()以生成数组内容的简单表示。例如，考虑这个Person对象数组：

Person[] people = { new Person("Fred"), new Person("Mike") };
System.out.println(Arrays.toString(people));

// Prints: [Fred, Mike]

Note: this is a call to a staticmethod called toString()in the Arrays class, which is different to what we've been discussing above.

注意：这是对 Arrays 类中调用的静态方法的调用toString()，这与我们上面讨论的不同。

If you have a multi-dimensional array, you can use Arrays.deepToString()to achieve the same sort of output.

如果你有一个多维数组，你可以用它Arrays.deepToString()来实现同样的输出。

Collections

收藏

Most collections will produce a pretty output based on calling .toString()on every element.

大多数集合将基于.toString()对每个元素的调用产生漂亮的输出。

List<Person> people = new ArrayList<>();
people.add(new Person("Alice"));
people.add(new Person("Bob"));    
System.out.println(people);

// Prints [Alice, Bob]

So you just need to ensure your list elements define a nice toString()as discussed above.

所以你只需要确保你的列表元素定义了一个toString()如上所述的好。

回答by Pankaj Manali

Every class in Java has the toString()method in it by default, which is called if you pass some object of that class to System.out.println(). By default, this call returns the className@hashcode of that object.

toString()默认情况下，Java 中的每个类都包含该方法，如果将该类的某个对象传递给System.out.println(). 默认情况下，此调用返回该对象的 className@hashcode。

{
    SomeClass sc = new SomeClass();
    // Class @ followed by hashcode of object in Hexadecimal
    System.out.println(sc);
}

You can override the toString method of a class to get different output. See this example

您可以覆盖类的 toString 方法以获得不同的输出。看这个例子

class A {
    String s = "I am just a object";
    @Override
    public String toString()
    {
        return s;
    }
}

class B {
    public static void main(String args[])
    {
        A obj = new A();
        System.out.println(obj);
    }
}

回答by Rohith K

I think apache provides a better util class which provides a function to get the string

我认为 apache 提供了一个更好的 util 类，它提供了一个获取字符串的函数

ReflectionToStringBuilder.toString(object)

回答by ketankk

In Eclipse, Go to your class, Right click->source->Generate toString();

在 Eclipse 中，转到您的类，右键单击->source->Generate toString()；

It will override the toString()method and will print the object of that class.

它将覆盖该toString()方法并打印该类的对象。

回答by Vikrant Kashyap

If you Directly print any object of Person It will the ClassName@HashCodeto the Code.

如果您直接打印 Person 的任何对象，则会将其ClassName@HashCode写入代码。

in your case com.foo.Person@2f92e0f4is getting printed . Where Personis a class to which object belongs and 2f92e0f4is hashCode of the Object.

在你的情况下com.foo.Person@2f92e0f4正在打印。其中Person是对象所属的类，是对象的2f92e0f4hashCode。

public class Person {
  private String name;

  public Person(String name){
  this.name = name;
  }
  // getter/setter omitted

   @override
   public String toString(){
        return name;
   }
}

Now if you try to Use the object of Personthen it will print the name

现在，如果您尝试使用对象，Person那么它将打印名称

Class Test
 {
  public static void main(String... args){
    Person obj = new Person("YourName");
    System.out.println(obj.toString());
  }
}

回答by Mr.Q

In intellij you can auto generate toString method by pressing alt+inset and then selecting toString() here is an out put for a test class:

在 intellij 中，您可以通过按 alt+inset 自动生成 toString 方法，然后选择 toString() 这里是测试类的输出：

public class test  {
int a;
char b;
String c;
Test2 test2;

@Override
public String toString() {
    return "test{" +
            "a=" + a +
            ", b=" + b +
            ", c='" + c + '\'' +
            ", test2=" + test2 +
            '}';
 }
}

As you can see, it generates a String by concatenating, several attributes of the class, for primitives it will print their values and for reference types it will use their class type (in this case to string method of Test2).

如您所见，它通过连接类的几个属性来生成一个字符串，对于基元，它将打印它们的值，对于引用类型，它将使用它们的类类型（在这种情况下是 Test2 的字符串方法）。

回答by Yasir Shabbir Choudhary

If you look at the Object class (Parent class of all classes in Java) the toString() method implementation is

如果您查看 Object 类（Java 中所有类的父类），则 toString() 方法实现是

    public String toString() {
       return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

whenever you print any object in Java then toString() will be call. Now it's up to you if you override toString() then your method will call other Object class method call.

每当您在 Java 中打印任何对象时，都会调用 toString()。现在取决于您是否覆盖 toString() 然后您的方法将调用其他 Object 类方法调用。

回答by adn.911

By default, every Object in Java has the toString()method which outputs the ObjectType@HashCode.

默认情况下，Java 中的每个对象都有toString()输出 ObjectType@HashCode 的方法。

If you want more meaningfull information then you need to override the toString()method in your class.

如果您想要更有意义的信息，那么您需要覆盖toString()类中的方法。

public class Person {
  private String name;

  // constructor and getter/setter omitted

  // overridding toString() to print name
  public String toString(){
     return name;  
  }
}

Now when you print the person object using System.out.prtinln(personObj);it will print the name of the person instead of the classname and hashcode.

现在，当您使用System.out.prtinln(personObj);它打印人员对象时，将打印人员的姓名而不是类名和哈希码。

In your second case when you are trying to print the array, it prints [Lcom.foo.Person;@28a418fcthe Array type and it's hashcode.

在第二种情况下，当您尝试打印数组时，它会打印[Lcom.foo.Person;@28a418fcArray 类型及其哈希码。

---

---

If you want to print the person names, there are many ways.

如果要打印人名，有很多方法。

You could write your own function that iterates each person and prints

您可以编写自己的函数来迭代每个人并打印

void printPersonArray(Person[] persons){
    for(Person person: persons){
        System.out.println(person);
    }
}

You could print it using Arrays.toString(). This seems the simplest to me.

您可以使用 Arrays.toString() 打印它。这对我来说似乎是最简单的。

 System.out.println(Arrays.toString(persons));
 System.out.println(Arrays.deepToString(persons));  // for nested arrays  

You could print it the java 8 way (using streams and method reference).

您可以以 java 8 方式打印它（使用流和方法引用）。

 Arrays.stream(persons).forEach(System.out::println);

There might be other ways as well. Hope this helps. :)

可能还有其他方式。希望这可以帮助。:)

回答by Agam

I prefer to use a utility function which uses GSONto de-serialize the Java object into JSON string.

我更喜欢使用一个实用函数，它使用GSON将 Java 对象反序列化为 JSON 字符串。

/**
 * This class provides basic/common functionalities to be applied on Java Objects.
 */
public final class ObjectUtils {

    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();

    private ObjectUtils() {
         throw new UnsupportedOperationException("Instantiation of this class is not permitted in case you are using reflection.");
    }

    /**
     * This method is responsible for de-serializing the Java Object into Json String.
     *
     * @param object Object to be de-serialized.
     * @return String
     */
    public static String deserializeObjectToString(final Object object) {
        return GSON.toJson(object);
    }
}