Java String.format(): Format Specifiers Explained

Last updated: October 15, 2026

You're building a receipt for your Android app. You want prices aligned, decimals consistent, and totals easy to read. String concatenation gets messy fast—mixing in plus signs and spaces by hand makes code harder to read and easier to break.

The solution sits in Java's standard library: String.format(). It handles alignment, padding, and locale-aware output without you counting spaces manually. Format specifiers do the heavy lifting.

The short version:

• Specifiers follow %[index$][flags][width][.precision]conversion
• Indexes let you reuse or reorder arguments
• Flags control padding, signs, and number grouping
• Locale-aware output adapts for international users

Format Specifier Basics

Every specifier starts with % and ends with a conversion character. Common conversions: s for strings, d for integers, f for floating point, t for dates, n for line breaks.

Position arguments let you reuse values or reorder output. The first argument is $1, the second is $2, and so on.

Consider formatting fruit names. You can display them in any order without changing the underlying data:

“`java

String[] fruits = new String[] { "Mango", "Grapes", "Banana", "Kiwi" };

System.out.println(String.format("My favourite fruits are %1$s, %2$s, %3$s and %4$s", fruits));

“`

This outputs "My favourite fruits are Mango, Grapes, Banana and Kiwi". Change %1$s to %4$s and you get Kiwi first instead. One array, flexible ordering.

Line breaks use %n instead of \n. It adapts to your operating system's line separator automatically:

“`java

String.format("Address:-%nUnit 505,%n32 Cross Street", null)

“`

Width specifiers enforce minimum character counts. The value gets padded with leading spaces if needed. With a width of 13 applied to "foo", you get ten leading spaces followed by the word itself—three characters of content plus ten of padding equals the specified width.

Number Formatting Deep Dive

Decimal precision matters for floating-point output. The .precision modifier controls how many digits appear after the decimal point. A formatter of .1f rounds to one decimal place; .5f shows five digits; .10f shows ten.

Applied to Math.PI, these produce 3.1, 3.14159, and 3.1415926536 respectively. The raw value 3.141592653589793 gets trimmed according to your specification.

Width specifiers work with floating-point numbers too. %10f produces at least ten characters, adding leading spaces as needed. The floating-point value displays right-aligned within that space.

Different flags change how numbers appear. The + flag forces a sign to display for positive values. The 0 flag enables zero-padding instead of space-padding. The ( flag encloses negative numbers in parentheses—a common accounting convention.

Locale awareness becomes critical for international applications. The French locale formats the same floating-point value with a comma as the decimal separator instead of a period. The number displays as 3,141593 rather than 3.141593.

Large numbers benefit from grouping separators. Applying grouping to a nine-digit value produces 1,234,567,890—readable at a glance. Without the grouping flag, it prints as one unbroken stream of digits.

Why This Matters

String concatenation works for simple cases. Once formatting needs complexity—consistent alignment, locale awareness, reusable templates—hand-rolled solutions fall apart. Format specifiers provide a standardized syntax that developers recognize immediately.

For Android developers, locale awareness matters especially. Your users span multiple countries. Price displays, date formats, and measurement units vary by region. Using String.format() with appropriate Locale parameters ensures your app looks natural to everyone.

The position argument feature deserves more attention than it usually gets. Being able to reference the same argument multiple times without recomputing it simplifies templates. It also makes code easier to maintain—change the value once, and every reference updates automatically.

Print Methods Compared

System.out.printf and System.out.format do the same work as String.format() but print directly instead of returning a string. When you need both—the formatted value and console output—use String.format(). When you only need printing, the shorter alternatives work fine.

For logging scenarios, String.format() lets you build the message once and handle it two ways: log it or return it for display. That flexibility proves valuable in larger applications.

Bottom Line

Format specifiers follow a learnable pattern. Master the basics—string padding, decimal precision, positional arguments—and you'll handle most formatting tasks confidently. Add locale awareness when your app serves international users. The investment in learning the syntax pays dividends every time you need clean, consistent output.

Key takeaways

• Use positional arguments (%1$s, %2$s) to reorder or reuse values without recomputing them
• Apply width specifiers for aligned columns in reports and receipts
• Choose locale-aware formatting for any number or date your users see
• Reserve System.out.printf and System.out.format for direct printing; use String.format() when you need the string too