Java Formatter Online — Format Java Code

Beautify Java classes, interfaces, lambdas, streams, and records with K&R braces and 4-space indentation following Oracle Java Code Conventions — 100% in your browser.

Input Java

Formatted Output

What is a Java Formatter?

A Java formatter reformats Java source code with K&R brace placement, consistent indentation, and idiomatic spacing for generics, lambdas, streams, and method references. It is the fastest way to make code from Stack Overflow, JAXB-generated bindings, MapStruct output, or auto-decompiled JARs readable.

Two conventions dominate modern Java: Oracle Java Code Conventions (4-space indent, 80-column limit, K&R braces) and Google Java Style (2-space indent, 100-column limit, alphabetical imports). Both use K&R braces — Allman is essentially never seen in Java. The formatter defaults to 4-space Oracle indentation; the resulting bytecode is byte-identical regardless of whitespace.

How to format Java code — 4 steps

Paste your Java code. Copy a class, method, lambda chain, or any Java snippet into the Input panel. Click Load Sample to try a demo.
Click Format. The formatter applies K&R braces and 4-space indentation client-side — no upload.
Review the output. The Output panel shows beautified Java ready for IntelliJ, Eclipse, or VS Code.
Copy the result. Click Copy to paste the formatted code into your editor or pull request.

Side-by-side: unformatted vs formatted Java

Unformatted

public class Main{public static void main(String[] args){double total=0;for(String a:args){total+=Double.parseDouble(a);}System.out.println(total);}}

Formatted (K&R)

public class Main {
    public static void main(String[] args) {
        double total = 0;
        for (String a : args) {
            total += Double.parseDouble(a);
        }
        System.out.println(total);
    }
}

K&R Brace Style

Opening braces on the same line as the declaration — the universal Java convention used by the JDK source, Effective Java, and every major style guide.

Bytecode Identical

Java is whitespace-insensitive outside string literals. Formatted source compiles to byte-identical .class files.

Client-Side Only

Code with JDBC URLs, API tokens, or proprietary algorithms never leaves your browser. Verify in DevTools → Network.

Common use cases

check_circleFormat auto-generated Java from JAXB, JPA, MapStruct, or protobuf compilers
check_circleReformat Java copied from Stack Overflow, Baeldung, or the official Java tutorials
check_circleBeautify decompiled Java (Procyon, CFR, Fernflower) to inspect a JAR
check_circleNormalise Java indentation after a merge conflict resolution
check_circleFormat Java inside a pull request review when the diff is unreadable
check_circleClean up generated Spring Data JPA repository code
check_circleReformat lambda chains and stream pipelines onto multiple lines
check_circleBeautify Java pasted from a chat, gist, or Confluence page for sharing

Online formatter vs google-java-format vs Spotless

An online formatter is the fastest tool for one-off snippets — paste, click, copy. google-java-format is the official Google CLI/library: it re-prints the AST and enforces Google Java Style strictly, with no configuration. Spotless is a Gradle/Maven plugin that runs google-java-format (or Eclipse JDT, or Palantir) as part of your build and fails CI on style violations. Use this online tool for one-off formatting; configure Spotless in your build for repository-wide enforcement.

More than formatting

Convert JSON to POJOs, escape strings, and parse JSON in Java — all browser-side.

JSON to Java Java String Escape Parse JSON in Java

Frequently Asked Questions

Which brace style does Java use — K&R or Allman?

Java idiomatic style is K&R (also called Egyptian or 1TBS): the opening brace stays on the same line as the declaration. This is the convention in Oracle Java Code Conventions, Google Java Style, the JDK source, and Effective Java. Allman braces are uncommon in Java and most static analysis tools flag them. The formatter applies K&R by default.

What is the difference between Google Java Style and Sun/Oracle conventions?

Two main differences: indentation (Google uses 2 spaces, Oracle uses 4) and column limit (Google limits to 100, Oracle to 80). Google Java Style also enforces alphabetical import order and forbids wildcard imports. The formatter defaults to 4-space Oracle indentation but works with both — what matters is that you pick one and stay consistent across a codebase.

How should imports be grouped?

Oracle convention: java.* first, then javax.*, then org.*, then com.*, with a blank line between groups. Google Java Style: a single block sorted alphabetically with no grouping (except static imports above non-static). IntelliJ defaults follow Oracle; google-java-format applies Google style. Pick the convention that matches your build tool and configure your editor accordingly.

Does formatting Java change compiled bytecode?

No. Java is whitespace-insensitive outside of string literals (and text blocks, which preserve their interior whitespace deliberately). The compiler produces byte-identical .class files from formatted and unformatted source.

How are lambdas and method references formatted?

Single-expression lambdas stay on one line: list.stream().map(x -> x.name()). Multi-statement lambdas use a block with K&R braces and the body indented one level. Method references (Order::amount) and chained streams break onto multiple lines when the chain exceeds the column limit, with each operator starting a new line aligned under the source.

Is the Java code I paste sent to your servers?

No. Formatting runs entirely in your browser using JavaScript. Code containing JDBC URLs, API tokens, proprietary algorithms, or internal package names never leaves your device. Open DevTools → Network and click Format to verify.

Does it format records, sealed classes, and pattern matching?

Yes. Java 14 records, Java 17 sealed interfaces and classes, Java 21 pattern matching for switch, and record deconstruction patterns are all formatted with K&R braces and standard indentation. Text blocks (""" ... """) preserve their interior content exactly.

How is this different from google-java-format or Spotless?

google-java-format is a CLI/library that re-prints the AST and enforces Google Java Style strictly — no configuration. Spotless is a Gradle/Maven plugin that wraps multiple formatters (google-java-format, Eclipse JDT, Palantir) and runs them in CI. This online tool is lighter: it normalises indentation and braces only, ideal for snippets pasted from Stack Overflow or generated code where you do not want full project rules applied.