@ToString

No need to start a debugger to see your fields: Just let lombok generate a toString for you!

Overview

Any class definition may be annotated with @ToString to let lombok generate an implementation of the toString() method. By default, it'll print your class name, along with each field, in order, separated by commas.

By setting the includeFieldNames parameter to true you can add some clarity (but also quite some length) to the output of the toString() method.

By default, all non-static fields will be printed. If you want to skip some fields, you can name them in the exclude parameter; each named field will not be printed at all. Alternatively, you can specify exactly which fields you wish to be used by naming them in the of parameter.

By setting callSuper to true, you can include the output of the superclass implementation of toString to the output. Be aware that the default implementation of toString() in java.lang.Object is pretty much meaningless, so you probably don't want to do this unless you are extending another class.

With Lombok

01 import lombok.ToString;
02 
03 @ToString(excludes="id")
04 public class ToStringExample {
05   private static final int STATIC_VAR = 10;
06   private String name;
07   private Shape shape = new Square(5, 10);
08   private String[] tags;
09   private int id;
10   
11   public String getName() {
12     return this.getName();
13   }
14   
15   @ToString(callSuper=true, includeFieldNames=true)
16   public static class Square extends Shape {
17     private final int width, height;
18     
19     public Square(int width, int height) {
20       this.width = width;
21       this.height = height;
22     }
23   }
24 }

Vanilla Java

01 import java.util.Arrays;
02 
03 public class ToStringExample {
04   private static final int STATIC_VAR = 10;
05   private String name;
06   private Shape shape = new Square(5, 10);
07   private String[] tags;
08   private int id;
09   
10   public String getName() {
11     return this.getName();
12   }
13   
14   public static class Square extends Shape {
15     private final int width, height;
16     
17     public Square(int width, int height) {
18       this.width = width;
19       this.height = height;
20     }
21     
22     @Override public String toString() {
23       return "Square(super=" + super.toString() + ", width=" + this.width + ", height=" + this.height + ")";
24     }
25   }
26   
27   @Override public String toString() {
28     return "ToStringExample(" + this.getName() + ", " + this.shape + ", " + Arrays.deepToString(this.tags) + ")";
29   }
30 }

Small print

If there is any method named toString regardless of parameters or return type, no method will be generated, and instead a warning is emitted explaining that your @ToString annotation is doing nothing.

Arrays are printed via Arrays.deepToString, which means that arrays that contain themselves will result in StackOverflowErrors. However, this behaviour is no different from e.g. ArrayList.

Attempting to exclude fields that don't exist or would have been excluded anyway (because they are static) results in warnings on the named fields. You therefore don't have to worry about typos.

Having both exclude and of generates a warning; the exclude parameter will be ignored in that case.

We don't promise to keep the output of the generated toString() methods the same between lombok versions. You should never design your API so that other code is forced to parse your toString() output anyway!

By default, any variables that start with a $ symbol are excluded automatically. You can only include them by using the 'of' parameter.

If a getter exists for a field to be included, it is called instead of using a direct field reference. This behaviour can be suppressed:
@ToString(doNotUseGetters = true)