Java Code Formatter

Two styles, two engines

The Style option switches between two separate formatters rather than two settings of one.

Prettier Java (the default) is prettier-plugin-java, the Java plugin for Prettier. It follows the toolbar’s Indent setting, which starts at 4 spaces for Java, wraps at 80 columns, and puts each argument of a long call on its own line with the closing parenthesis on a new line, the same way Prettier formats JavaScript. It also inserts a blank line after a class’s opening brace. Teams that already use Prettier for a TypeScript front end often pick it so both halves of a repository look alike.

google-java-format is Google’s own formatter, compiled to WebAssembly. It implements the Google Java Style Guide and has no knobs: indentation is always 2 spaces, continuation lines get 4, and the column limit is 100, so the toolbar’s Indent choice has no effect. Long method chains break before each dot. It is the style enforced by many Gradle and Maven plugins such as Spotless, so pick it if your build already checks for it.

Imports, snippets and other differences

Both styles sort the import block, but google-java-format goes further and deletes imports the file never uses, just like its command-line tool. Prettier Java keeps every import you wrote.

The two parsers also disagree on what counts as valid input. Prettier Java accepts fragments: a lone method, a field or a single statement such as a System.out.println call all format fine, which is convenient for code copied out of a stack trace or a tutorial. google-java-format needs a real compilation unit and stops with “class, interface, enum, or record expected” on anything less, so wrap a fragment in class Snippet { ... } before switching styles.

Modern syntax works in both: records, sealed interfaces, switch expressions with arrow labels, pattern matching for instanceof, var and text blocks. Text blocks are handled differently, though. Prettier Java keeps the opening triple quote on the same line as the assignment, while google-java-format moves it to the next line and re-indents the block.

How to format Java here

Paste the source or drop a .java file in. Detection looks for a class, interface, record or enum declaration together with something unmistakably Java, such as import java., @Override or a package com.example; line. Pick a Style, then use Ctrl/Cmd+Enter to format. Ctrl/Cmd+K opens the command palette, where typing “2 spaces” changes the indentation for Prettier Java without reaching for the mouse. Nothing is uploaded, so proprietary service code and the connection strings people tend to leave in it stay on your machine.

Keeping a block as written

Prettier Java honours // prettier-ignore on the line before a declaration or statement, and it skips everything between // @formatter:off and // @formatter:on, the markers Eclipse and IntelliJ also use. Hand-aligned lookup tables and matrices are the usual reason to reach for them. google-java-format has no equivalent, so ignored regions only work with the Prettier Java style.

Examples

@RestController
@RequestMapping("/api/orders")
public class OrderController{private final OrderService service;public OrderController(OrderService service){this.service=service;}
@GetMapping("/{id}") public ResponseEntity<OrderDto> get(@PathVariable String id){return service.find(id).map(ResponseEntity::ok).orElseGet(()->ResponseEntity.notFound().build());}}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
  private final OrderService service;

  public OrderController(OrderService service) {
    this.service = service;
  }

  @GetMapping("/{id}")
  public ResponseEntity<OrderDto> get(@PathVariable String id) {
    return service
        .find(id)
        .map(ResponseEntity::ok)
        .orElseGet(() -> ResponseEntity.notFound().build());
  }
}

package com.example.billing;
import java.util.List;
import java.math.BigDecimal;
public class Invoices{public record Line(String sku,int qty,BigDecimal unitPrice){}
public enum Status{DRAFT,SENT,PAID}
public static String label(Status s){return switch(s){case DRAFT->"Draft";case SENT->"Awaiting payment";case PAID->"Paid";};}
public static BigDecimal total(List<Line> lines){return lines.stream().map(l->l.unitPrice().multiply(BigDecimal.valueOf(l.qty()))).reduce(BigDecimal.ZERO,BigDecimal::add);}}

package com.example.billing;

import java.math.BigDecimal;
import java.util.List;

public class Invoices {

    public record Line(String sku, int qty, BigDecimal unitPrice) {}

    public enum Status {
        DRAFT,
        SENT,
        PAID,
    }

    public static String label(Status s) {
        return switch (s) {
            case DRAFT -> "Draft";
            case SENT -> "Awaiting payment";
            case PAID -> "Paid";
        };
    }

    public static BigDecimal total(List<Line> lines) {
        return lines
            .stream()
            .map(l -> l.unitPrice().multiply(BigDecimal.valueOf(l.qty())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

public Optional<Customer> findByEmail(String email){if(email==null||email.isBlank()){return Optional.empty();}return customers.stream().filter(c->c.email().equalsIgnoreCase(email)).findFirst();}

public Optional<Customer> findByEmail(String email) {
  if (email == null || email.isBlank()) {
    return Optional.empty();
  }
  return customers
    .stream()
    .filter(c -> c.email().equalsIgnoreCase(email))
    .findFirst();
}

Common errors and how to fix them

Related tools

• JSON to Java
• Kotlin formatter
• C# formatter
• XML formatter
• Java .properties formatter
• YAML formatter
• C / C++ / Objective-C formatter