Java String Format: String.format, printf, and Format Specifiers

Two Ways to Format

Java formats strings from a template containing format specifiers (the % placeholders) plus the values to drop in. There are two entry points, and they share identical syntax:

• String.format(template, values...) returns a new String.
• System.out.printf(template, values...) prints the result directly.

public class Main {
    public static void main(String[] args) {
        String name = "Ada";
        int age = 36;

        String line = String.format("%s is %d years old", name, age);
        System.out.println(line);

        System.out.printf("%s is %d years old%n", name, age);
    }
}

Both produce the same text. String.format hands it back so you can store it; printf writes it to the console. Note the %n at the end of the printf template - that is the platform-independent newline (prefer it over \n in format strings).

The Common Specifiers

Each specifier starts with % and ends with a letter that says what kind of value to expect:

public class Main {
    public static void main(String[] args) {
        System.out.printf("string: %s%n", "hello");
        System.out.printf("integer: %d%n", 42);
        System.out.printf("float: %f%n", 3.14);
        System.out.printf("boolean: %b%n", true);
        System.out.printf("char: %c%n", 'A');
        System.out.printf("hex: %x%n", 255);
        System.out.printf("percent sign: %%%n");
    }
}

The everyday three are %s (any value, via its toString), %d (whole numbers), and %f (decimals). Use %% to print a literal percent sign. Passing the wrong type - say a String to %d - throws an IllegalFormatConversionException at run time.

Controlling Decimal Places

%f defaults to six decimal places, which is rarely what you want. Put .N before the f to fix the precision (the value is rounded):

public class Main {
    public static void main(String[] args) {
        double price = 3.14159;

        System.out.printf("%f%n", price);     // 3.141590
        System.out.printf("%.2f%n", price);   // 3.14
        System.out.printf("%.0f%n", price);   // 3
    }
}

Add a comma flag for grouping separators on large numbers:

public class Main {
    public static void main(String[] args) {
        double total = 1234567.891;
        System.out.printf("%,.2f%n", total);   // 1,234,567.89
    }
}

Width and Padding

A number between the % and the type letter sets a minimum field width, padding with spaces so columns line up. A leading - left-aligns; a leading 0 pads numbers with zeros:

public class Main {
    public static void main(String[] args) {
        System.out.printf("[%10s]%n", "hi");    // right-aligned in 10 cols
        System.out.printf("[%-10s]%n", "hi");   // left-aligned
        System.out.printf("[%05d]%n", 42);      // zero-padded to width 5
    }
}

This is what makes formatted tables and aligned reports readable, especially when you print each row inside a for loop:

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ada", "Boris", "Chen"};
        int[] scores = {95, 8, 142};

        for (int i = 0; i < names.length; i++) {
            System.out.printf("%-8s %5d%n", names[i], scores[i]);
        }
    }
}

The %-8s left-aligns names in an 8-wide column and %5d right-aligns scores in a 5-wide column, so the numbers line up regardless of digit count.

Argument Order

By default specifiers consume values left to right. You can repeat or reorder a value with N$ (one-based index), handy when the same value appears twice:

public class Main {
    public static void main(String[] args) {
        System.out.printf("%1$s, %1$s, hello %2$s%n", "echo", "world");
    }
}

%1$s refers to the first argument both times, so echo prints twice.

The formatted() Method

Since Java 15, every string has a formatted instance method - the same engine as String.format, just written as a method call on the template:

public class Main {
    public static void main(String[] args) {
        String msg = "%s scored %d".formatted("Ada", 95);
        System.out.println(msg);
    }
}

It pairs especially well with text blocks (triple-quoted multi-line strings) when building larger formatted output.

When Not to Use String.format

For simple one-off joins, plain concatenation with + is clearer and faster:

String greeting = "Hi, " + name + "!";   // simpler than String.format here

Reach for String.format / printf when you need real formatting - fixed decimal places, padding, alignment, grouping - not just gluing a couple of values together.

Next: Operators

Formatting turns values into text. To compute those values in the first place you need Java's operators - arithmetic, comparison, and logical. That is the next page.