Project Lombok

https://projectlombok.org/
Admin
Project Lombok is a Java library that automatically generates boilerplate code through annotations,...
Tokens:114,233
Snippets:1,411
Trust Score:9.8
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Vanilla Java equivalent of onX example

Source: https://projectlombok.org/features/experimental/onX

Shows the equivalent vanilla Java code that Lombok's onX example generates, with annotations placed directly on the constructor, getter, and setter parameter.

```java
import javax.inject.Inject;
import javax.persistence.Id;
import javax.persistence.Column;
import javax.validation.constraints.Max;

public class OnXExample {
  private long unid;

  @Inject
  public OnXExample(long unid) {
    this.unid = unid;
  }

  @Id @Column(name="unique-id")
  public long getUnid() {
    return unid;
  }

  public void setUnid(@Max(10000) long unid) {
    this.unid = unid;
  }
}
```

--------------------------------

### Vanilla Java equivalent for @Accessors examples

Source: https://projectlombok.org/features/experimental/Accessors

Shows the equivalent vanilla Java code that Lombok would generate for the @Accessors examples: fluent getter/setter for age and a getter with prefix stripped for fName.

```java
public class AccessorsExample {
  private int age = 10;
  
  public int age() {
    return this.age;
  }
  
  public AccessorsExample age(final int age) {
    this.age = age;
    return this;
  }
}

class PrefixExample {
  private String fName = "Hello, World!";
  
  public String getName() {
    return this.fName;
  }
}
```

--------------------------------

### Before and After @ExtensionMethod Example

Source: https://projectlombok.org/api/lombok/experimental/ExtensionMethod

Shows the before and after of using @ExtensionMethod. The before block uses extension methods on an array, while the after block shows the equivalent standard Java code without the annotation.

```java
@ExtensionMethod(java.util.Arrays.class)
class Example {
        private void example() {
                long[] values = new long[] { 2, 5, 7, 9 };
                values.copyOf(3).sort();
        }
}

```

```java
class Example {
        private void example() {
                long[] values = new long[] { 2, 5, 7, 9 };
                java.util.Arrays.sort(java.util.Arrays.copyOf(values, 3));
        }
}

```

--------------------------------

### Vanilla Java equivalent without lombok.val

Source: https://projectlombok.org/features/val

Shows the equivalent vanilla Java code that the Lombok val example compiles to; explicit final keyword and types are required. Useful for comparing the transformation.

```java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class ValExample {
  public String example() {
    final ArrayList<String> example = new ArrayList<String>();
    example.add("Hello, World!");
    final String foo = example.get(0);
    return foo.toLowerCase();
  }
  
  public void example2() {
    final HashMap<Integer, String> map = new HashMap<Integer, String>();
    map.put(0, "zero");
    map.put(5, "five");
    for (final Map.Entry<Integer, String> entry : map.entrySet()) {
      System.out.printf("%d: %s\n", entry.getKey(), entry.getValue());
    }
  }
}
```

--------------------------------

### Write the equivalent vanilla Java utility class

Source: https://projectlombok.org/features/experimental/UtilityClass

Equivalent vanilla Java code for the @UtilityClass example. It manually marks the class final, makes the constant static, adds a private constructor that throws UnsupportedOperationException, and makes the method static.

```java
public final class UtilityClassExample {
  private static final int CONSTANT = 5;

  private UtilityClassExample() {
    throw new java.lang.UnsupportedOperationException("This is a utility class and cannot be instantiated");
  }

  public static int addSomething(int in) {
    return in + CONSTANT;
  }
}
```

--------------------------------

### Delegate field example

Source: https://projectlombok.org/api/lombok/experimental/Delegate

Place on any field to make Lombok generate delegate methods that forward calls to this field. In this example, methods from List such as boolean add(String) are generated, forwarding to foo.add(arg).

```java
private @Delegate List<String> foo;
```

--------------------------------

### Vanilla Java ToString Example

Source: https://projectlombok.org/features/ToString

Shows the manual implementation of toString() methods for the same classes as the Lombok example. The outer class's toString() includes the name, shape, and tags fields, using Arrays.deepToString for the array. The nested Square class's toString() includes the superclass toString() and its width and height fields.

```java
import java.util.Arrays;

public class ToStringExample {
  private static final int STATIC_VAR = 10;
  private String name;
  private Shape shape = new Square(5, 10);
  private String[] tags;
  private int id;
  
  public String getName() {
    return this.name;
  }
  
  public static class Square extends Shape {
    private final int width, height;
    
    public Square(int width, int height) {
      this.width = width;
      this.height = height;
    }
    
    @Override public String toString() {
      return "Square(super=" + super.toString() + ", width=" + this.width + ", height=" + this.height + ")";
    }
  }
  
  @Override public String toString() {
    return "ToStringExample(" + this.getName() + ", " + this.shape + ", " + Arrays.deepToString(this.tags) + ")";
  }
}
```

--------------------------------

### Lombok @ToString Example

Source: https://projectlombok.org/features/ToString

Shows how to use Lombok's @ToString annotation to generate toString() methods. The example includes a class with a static field, instance fields, an array, and an excluded field using @ToString.Exclude. The nested class uses @ToString(callSuper=true, includeFieldNames=true) to include superclass fields and field names.

```java
import lombok.ToString;

@ToString
public class ToStringExample {
  private static final int STATIC_VAR = 10;
  private String name;
  private Shape shape = new Square(5, 10);
  private String[] tags;
  @ToString.Exclude private int id;
  
  public String getName() {
    return this.name;
  }
  
  @ToString(callSuper=true, includeFieldNames=true)
  public static class Square extends Shape {
    private final int width, height;
    
    public Square(int width, int height) {
      this.width = width;
      this.height = height;
    }
  }
}
```

--------------------------------

### Run delombok on command line (directory)

Source: https://projectlombok.org/features/delombok

Copies the src directory into src-delomboked (created if missing), applying Lombok transformations to Java sources and skipping class files. The destination directory is created automatically if it does not already exist.

```bash
java -jar lombok.jar delombok src -d src-delomboked
```

--------------------------------

### @ExtensionMethod Annotation

Source: https://projectlombok.org/api/lombok/experimental/ExtensionMethod

Documentation for the Lombok @ExtensionMethod annotation, including its declaration, required and optional elements, and usage example.

```APIDOC
## @ExtensionMethod

### Description
Extension methods enable you to "add" methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called as if they were instance methods on the extended type.

### Annotation Declaration
```java
@Target(TYPE) @Retention(SOURCE) public @interface ExtensionMethod
```

### Required Elements

#### value
- **Type**: `Class<?>[]`
- **Description**: All types whose static methods will be exposed as extension methods.

### Optional Elements

#### suppressBaseMethods
- **Type**: `boolean`
- **Default**: `true`
- **Description**: If `true`, an applicable extension method is used (if found) even if the method call already was compilable (this is the default). If `false`, an extension method is only used if the method call is not also defined by the type itself.

### Example

Before:
```java
@ExtensionMethod(java.util.Arrays.class)
class Example {
        private void example() {
                long[] values = new long[] { 2, 5, 7, 9 };
                values.copyOf(3).sort();
        }
}
```

After:
```java
class Example {
        private void example() {
                long[] values = new long[] { 2, 5, 7, 9 };
                java.util.Arrays.sort(java.util.Arrays.copyOf(values, 3));
        }
}
```
```

--------------------------------

### Vanilla Java equivalent without @Helper

Source: https://projectlombok.org/features/experimental/Helper

Shows the equivalent vanilla Java code without @Helper, requiring manual instantiation of the local class and prefixing calls with the instance variable.

```java
public class HelperExample {
  int someMethod(int arg1) {
    int localVar = 5;

    class Helpers {
      int helperMethod(int arg) {
        return arg + localVar;
      }
    }
    Helpers $Helpers = new Helpers();

    return $Helpers.helperMethod(10);
  }
}
```

--------------------------------

### Vanilla Java equivalent of Lombok @Builder @Singular

Source: https://projectlombok.org/features/BuilderSingular

Shows the equivalent vanilla Java code that Lombok would generate for the @Builder @Singular example, including the builder class, singular and plural methods, clear methods, and the build() method that constructs the immutable collections.

```java
import java.util.Collection;
import java.util.Set;
import java.util.SortedMap;
import com.google.common.collect.ImmutableList;

public class SingularExample<T extends Number> {
  private Set<String> occupations;
  private ImmutableList<String> axes;
  private SortedMap<Integer, T> elves;
  private Collection<?> minutiae;
  
  SingularExample(Set<String> occupations, ImmutableList<String> axes, SortedMap<Integer, T> elves, Collection<?> minutiae) {
    this.occupations = occupations;
    this.axes = axes;
    this.elves = elves;
    this.minutiae = minutiae;
  }
  
  public static class SingularExampleBuilder<T extends Number> {
    private java.util.ArrayList<String> occupations;
    private com.google.common.collect.ImmutableList.Builder<String> axes;
    private java.util.ArrayList<Integer> elves$key;
    private java.util.ArrayList<T> elves$value;
    private java.util.ArrayList<java.lang.Object> minutiae;
    
    SingularExampleBuilder() {
    }
    
    public SingularExampleBuilder<T> occupation(String occupation) {
      if (this.occupations == null) {
        this.occupations = new java.util.ArrayList<String>();
      }
      
      this.occupations.add(occupation);
      return this;
    }
    
    @java.lang.SuppressWarnings("all")
    public SingularExampleBuilder<T> occupations(java.util.Collection<? extends String> occupations) {
      if (this.occupations == null) {
        this.occupations = new java.util.ArrayList<String>();
      }
      
      this.occupations.addAll(occupations);
      return this;
    }
    
    public SingularExampleBuilder<T> clearOccupations() {
      if (this.occupations != null) this.occupations.clear();
      return this;
    }
    
    public SingularExampleBuilder<T> axis(String axis) {
      if (this.axes == null) {
        this.axes = com.google.common.collect.ImmutableList.builder();
      }
      
      this.axes.add(axis);
      return this;
    }
    
    public SingularExampleBuilder<T> axes(java.lang.Iterable<? extends String> axes) {
      if (this.axes == null) {
        this.axes = com.google.common.collect.ImmutableList.builder();
      }
      
      this.axes.addAll(axes);
      return this;
    }
    
    public SingularExampleBuilder<T> clearAxes() {
      if (this.axes != null) this.axes.clear();
      return this;
    }
    
    public SingularExampleBuilder<T> elf(Integer elfKey, T elfValue) {
      if (this.elves$key == null) {
        this.elves$key = new java.util.ArrayList<Integer>();
        this.elves$value = new java.util.ArrayList<T>();
      }
      
      this.elves$key.add(elfKey);
      this.elves$value.add(elfValue);
      return this;
    }
    
    public SingularExampleBuilder<T> elves(java.util.Map<? extends Integer, ? extends T> elves) {
      if (this.elves$key == null) {
        this.elves$key = new java.util.ArrayList<Integer>();
        this.elves$value = new java.util.ArrayList<T>();
      }
      
      for (java.util.Map.Entry<? extends Integer, ? extends T> $lombokEntry : elves.entrySet()) {
        this.elves$key.add($lombokEntry.getKey());
        this.elves$value.add($lombokEntry.getValue());
      }
      return this;
    }
    
    public SingularExampleBuilder<T> clearElves() {
      if (this.elves$key != null) {
        this.elves$key.clear();
        this.elves$value.clear();
      }
      return this;
    }
    
    public SingularExampleBuilder<T> minutia(java.lang.Object minutia) {
      if (this.minutiae == null) {
        this.minutiae = new java.util.ArrayList<java.lang.Object>();
      }
      
      this.minutiae.add(minutia);
      return this;
    }
    
    public SingularExampleBuilder<T> minutiae(java.util.Collection<?> minutiae) {
      if (this.minutiae == null) {
        this.minutiae = new java.util.ArrayList<java.lang.Object>();
      }
      
      this.minutiae.addAll(minutiae);
      return this;
    }
    
    public SingularExampleBuilder<T> clearMinutiae() {
      if (this.minutiae != null) this.minutiae.clear();
      return this;
    }
    
    public SingularExampleBuilder<T> build() {
      java.util.Set<String> occupations;
      switch (this.occupations == null ? 0 : this.occupations.size()) {
        case 0: 
          occupations = java.util.Collections.emptySet();
          break;
        case 1: 
          occupations = java.util.Collections.singleton(this.occupations.get(0));
          break;
        default: 
          occupations = new java.util.LinkedHashSet<String>(this.occupations.size());
          occupations.addAll(this.occupations);
      }
      
      com.google.common.collect.ImmutableList<String> axes = this.axes == null ? com.google.common.collect.ImmutableList.<String>of() : this.axes.build();
      java.util.SortedMap<Integer, T> elves;
      switch (this.elves$key == null ? 0 : this.elves$key.size()) {
        case 0: 
          elves = new java.util.TreeMap<Integer, T>();
          break;
        case 1: 
          elves = Collections.singletonMap(this.elves$key.get(0), this.elves$value.get(0));
          break;
        default: 
          elves = new java.util.TreeMap<Integer, T>();
          for (int i = 0; i < this.elves$key.size(); i++) {
            elves.put(this.elves$key.get(i), this.elves$value.get(i));
          }
      }
      
      java.util.Collection<?> minutiae;
      switch (this.minutiae == null ? 0 : this.minutiae.size()) {
        case 0: 
          minutiae = java.util.Collections.emptyList();
          break;
        case 1: 
          minutiae = java.util.Collections.singletonList(this.minutiae.get(0));
          break;
        default: 
          minutiae = new java.util.ArrayList<java.lang.Object>(this.minutiae.size());
          minutiae.addAll(this.minutiae);
      }
      
      return new SingularExample<T>(occupations, axes, elves, minutiae);
    }
    
    @java.lang.Override
    public java.lang.String toString() {
      return "SingularExample.SingularExampleBuilder(occupations=" + this.occupations + ", axes=" + this.axes + ", elves$key=" + this.elves$key + ", elves$value=" + this.elves$value + ", minutiae=" + this.minutiae + ")";
    }
  }
}
```

--------------------------------

### Lombok @Data Example

Source: https://projectlombok.org/features/Data

Use Lombok's @Data annotation to automatically generate getters, setters, equals, hashCode, and toString for a data class. The example also uses @Setter(AccessLevel.PACKAGE) to restrict the setter's visibility and @ToString(includeFieldNames=true) to include field names in the toString output. The nested Exercise class uses @Data(staticConstructor="of") to generate a static factory method.

```java
import lombok.AccessLevel;
import lombok.Setter;
import lombok.Data;
import lombok.ToString;

@Data public class DataExample {
  private final String name;
  @Setter(AccessLevel.PACKAGE) private int age;
  private double score;
  private String[] tags;
  
  @ToString(includeFieldNames=true)
  @Data(staticConstructor="of")
  public static class Exercise<T> {
    private final String name;
    private final T value;
  }
}
```

--------------------------------

### Vanilla Java: Equivalent without @Tolerate

Source: https://projectlombok.org/features/experimental/Tolerate

Shows the same example without Lombok, where the method is named setDateFromString to avoid conflict with the generated setter.

```java
public class TolerateExample {
    @Setter
    private Date date;

    public void setDateFromString(String date) {
        this.date = Date.valueOf(date);
    }
}
```

--------------------------------

### Configure lombok.cleanup.flagUsage

Source: https://projectlombok.org/features/Cleanup

Configuration key to flag usage of @Cleanup as a warning or error. Default is not set.

```text
lombok.cleanup.flagUsage = [`warning` | `error`] (default: not set)
```

--------------------------------

### Clear lombok.val.flagUsage

Source: https://projectlombok.org/features/configuration

Restores a configuration key set by a parent config file back to the default. In this example, it turns off warnings for 'val' in a subdirectory.

```properties
clear lombok.val.flagUsage
```

--------------------------------

### Vanilla Java equivalent for @Delegate

Source: https://projectlombok.org/features/experimental/Delegate

Shows the equivalent vanilla Java code that Lombok would generate for the @Delegate examples. It includes explicit delegation methods for the SimpleCollection interface and, for the ExcludesDelegateExample, all Collection methods except add and addAll, which are overridden manually.

```java
import java.util.ArrayList;
import java.util.Collection;

public class DelegationExample {
  private interface SimpleCollection {
    boolean add(String item);
    boolean remove(Object item);
  }
  
  private final Collection<String> collection = new ArrayList<String>();
  
  @java.lang.SuppressWarnings("all")
  public boolean add(final java.lang.String item) {
    return this.collection.add(item);
  }
  
  @java.lang.SuppressWarnings("all")
  public boolean remove(final java.lang.Object item) {
    return this.collection.remove(item);
  }
}

class ExcludesDelegateExample {
  long counter = 0L;
  
  private interface Add {
    boolean add(String x);
    boolean addAll(Collection<? extends String> x);
  }
  
  private final Collection<String> collection = new ArrayList<String>();
  
  public boolean add(String item) {
    counter++;
    return collection.add(item);
  }
  
  public boolean addAll(Collection<? extends String> col) {
    counter += col.size();
    return collection.addAll(col);
  }
  
  @java.lang.SuppressWarnings("all")
  public int size() {
    return this.collection.size();
  }
  
  @java.lang.SuppressWarnings("all")
  public boolean isEmpty() {
    return this.collection.isEmpty();
  }
  
  @java.lang.SuppressWarnings("all")
  public boolean contains(final java.lang.Object arg0) {
    return this.collection.contains(arg0);
  }
  
  @java.lang.SuppressWarnings("all")
  public java.util.Iterator<java.lang.String> iterator() {
    return this.collection.iterator();
  }
  
  @java.lang.SuppressWarnings("all")
  public java.lang.Object[] toArray() {
    return this.collection.toArray();
  }
  
  @java.lang.SuppressWarnings("all")
  public <T extends .java.lang.Object>T[] toArray(final T[] arg0) {
    return this.collection.<T>toArray(arg0);
  }
  
  @java.lang.SuppressWarnings("all")
  public boolean remove(final java.lang.Object arg0) {
    return this.collection.remove(arg0);
  }
  
  @java.lang.SuppressWarnings("all")
  public boolean containsAll(final java.util.Collection<?> arg0) {
    return this.collection.containsAll(arg0);
  }
  
  @java.lang.SuppressWarnings("all")
  public boolean removeAll(final java.util.Collection<?> arg0) {
    return this.collection.removeAll(arg0);
  }
  
  @java.lang.SuppressWarnings("all")
  public boolean retainAll(final java.util.Collection<?> arg0) {
    return this.collection.retainAll(arg0);
  }
  
  @java.lang.SuppressWarnings("all")
  public void clear() {
    this.collection.clear();
  }
}
```
Tokens:
Raw