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

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 Person objects:

当我尝试打印一个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?

这个输出意味着什么?如何更改这个输出，使它包含我的person的名称?如何打印我的对象集合?

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

注意:这是一个关于这个主题的权威问答。

9 个解决方案

#1

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 Object class (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 hashcode of the object in hexadecimal. The code for this looks like:

此方法在对象类(所有Java对象的超类)中定义。tostring()方法返回一个非常难看的字符串，由类名、@符号和十六进制中对象的hashcode组成。它的代码如下:

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

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

一个结果，例如com.foo。MyType@2f92e0f4因此可以解释为:

• com.foo.MyType - the name of the class, i.e. the class is MyType in the package com.foo.
• com.foo。MyType——类的名称，即类在com.foo包中为MyType。
• @ - joins the string together
• @ -将字符串连接在一起
• 2f92e0f4 the hashcode of the object.
• 2f92e0f4对象的hashcode。

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

数组类的名称看起来有点不同，在Class.getName()的Javadocs中有很好的解释。例如,[Ljava.lang。字符串的意思是:

• [ - 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
• . lang。字符串——数组中对象的类型

---

Customizing the Output

To print something different when you call System.out.println(myObject), you must override the 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.

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

Bear in mind that toString() is just one way 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 Person class might be:

记住toString()只是将对象转换为字符串的一种方法。通常，这个输出应该以清晰和简洁的方式完整地描述您的对象。我们的Person类更好的toString()可能是:

@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() {...}.

如果您想只关注对象的一个方面或包含大量的jazzy格式，那么您最好定义一个单独的方法，例如，String toElegantReport(){…}。

---

Auto-generating the Output

Many IDEs offer support for auto-generating a toString() method, based on the fields in the class. See docs for Eclipse and IntelliJ, for example.

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

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

一些流行的Java库也提供了这个特性。一些例子包括:

• ToStringBuilder from Apache Commons Lang

  来自Apache Commons Lang的ToStringBuilder

• MoreObjects.ToStringHelper from Google Guava

  MoreObjects。从谷歌ToStringHelper番石榴

• @ToString annotation from Project Lombok

  @ToString来自项目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 Person objects:

如果有一个对象数组，可以调用array. 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 static method called toString() in the Arrays class, which is different to what we've been discussing above.

注意:这是对数组类中名为toString()的静态方法的调用，与前面讨论的不同。

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

如果您有一个多维数组，您可以使用array . 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()。

#2

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

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

ReflectionToStringBuilder.toString(object)

#3

Every class in java has toString() method in it by default, which is called by System.out.println() if you pass some object of a class to it. When you try to print object of a class, the System.out.println() method will call toString() of the class which returns the className@hashcode of that object.

java中的每个类在默认情况下都有toString()方法，如果您将类的某个对象传递给它，那么System.out.println()将调用这个方法。当尝试打印类的对象时，System.out.println()方法将调用类的toString()，该类返回该对象的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);
    }
}

#4

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

在Eclipse中，转到您的类，右击—>源—>生成toString();

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

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

#5

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

如果您直接打印任何Person对象，它将把ClassName@HashCode打印到代码中。

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

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

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 Person then it will print the name

现在，如果你尝试使用Person对象，它会打印出这个名字

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

#6

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的String方法)。

#7

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)打印person对象时;它将打印person的名称，而不是classname和hashcode。

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

在第二种情况下，当您试图打印数组时，它会打印[Lcom.foo.Person;@28a418fc数组类型，它是hashcode。

---

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.

您可以使用array . 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. :)

也许还有其他的方法。希望这个有帮助。:)

#8

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

如果查看对象类(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()，那么您的方法将调用其他对象类方法调用。

#9

Arrays.deepToString(arrayOfObject)

Above function print array of object of different primitives.

以上函数打印不同基元对象的数组。

[[AAAAA, BBBBB], [6, 12], [2003-04-01 00:00:00.0, 2003-10-01 00:00:00.0], [2003-09-30 00:00:00.0, 2004-03-31 00:00:00.0], [Interim, Interim], [2003-09-30, 2004-03-31]];