Java String format() Method

In Java, the String.format() method allows us to create a formatted string using a specified format string and arguments. We can concatenate the strings using this method, and at the same time, we can format the output with options such as width, alignment, decimal places, and more.

Example: In the example below, we will use the String.format() method to concatenate a string and format the output with a placeholder.

// Java program to demonstrate working of format() method
class Geeks
{
    public static void main(String args[]) {
      
        String s = "GeeksforGeeks";
        
        // Concatenate string 
        // using format()
        String res = String.format("Welcome to %s!", s);

        System.out.println(res);
    }
}

Welcome to GeeksforGeeks!

Explanation: In the above example, the format() method of the String class is used to insert the value of "s" into the formatted string. The placeholder %s is replaced with the string value.

Syntax of format() Method

There are two main versions of the format() method:

public static String format(Locale locale, String form, Object... args);

public static String format(String format, Object... args);

Parameters:

• locale: The locale value to be applied (optional).
• format: The format string that defines how the output should look.
• args: The arguments to be formatted as per the format string.

Return Type: The method returns a formatted string.

Exceptions:

• NullPointerException:If the format is null.
• IllegalFormatException:If the format specified is illegal or there are insufficient arguments.

Examples of String format() Method

1. Formatting Floating-Point Numbers

Example: Using String.format() method to show concatinate the two floating values of given variable using %2f.

// Java program to demonstrate floating-point 
// formatting with format()
class Geeks
{
    public static void main(String args[]) {
      
        double d = 9876.54321;
        
        // Format the float number with 
        // 2 decimal places
        String s = String.format("Formatted Value: %.2f", d);

        System.out.println(s);
    }
}

Formatted Value: 9876.54

Explanation: In this example, a floating-point number 9876.54321 is formatted to show only two decimal places using String.format(). The placeholder %.2f ensures that the value is rounded to two decimal places and displayed.

• %2f: The f specifier is for floating-point numbers, and .2 means the number should be rounded to two decimal places.
• The formatted value 9876.54 is printed with the label Formatted Value, by providing a more readable output.

2. Advanced Formatting with Decimal and Thousands Separator

In this example, we will specify the formatting options like grouping digits, for example, for large numbers and controlling the number of decimal places.

Example: Using String.format() method for advance formatting with decimal and thousands seperator.

// Java program to demonstrate 
// advanced formatting using format() method
class Geeks
{
    public static void main(String args[]) {
      
        // Define a double value 
        // representing a price
        double d = 12345.6789;
        
        // Format the price with thousands 
        // separator and two decimal places
        String s = String.format("%1$,10.2f", d);

        System.out.println("Formatted Price: " + s);
    }
}

Formatted Price:  12,345.68

Explanation: In the above example, it formats the floating-point number with a thousands separator and two decimal places. The number 12345.6789 is formatted to 12,345.68.

In the placeholder,

• %1$: It refers to the first argument (d), the price value.
• ,: It groups digits with a comma as a thousands separator.
• 10.2f: It ensures that the floating-point number takes at least 10 characters, with 2 decimal places.

3. Complex Placeholder Formatting

In this example, we will combine multiple formatting components to customize how the arguments should appear.

Example: Using String.format() method with complex placeholder formatting.

// Java program to demonstrate 
// complex placeholder formatting
class Geeks
{
    public static void main(String args[]) {

        // Declare a double value 
        // representing the distance
        double d = 1500.75;
      
        // Declare a string value 
        // representing the unit of measurement
        String s = "kilometers";

        // Correct the argument order to match the format specifiers
        String res = String.format("%1$,7.1f %2$s", d, s);

        System.out.println(res);
    }
}

1,500.8 kilometers

Explanation: In the above example, it formats a floating-point number and a string using placeholders in the String.format() method. The number 1500.75 is formatted with a comma separator and one decimal place, and the string "kilometers" is added next to it.

In the placeholder,

• %2$: Refers to the second argument i.e. "d" the distance.
• ,: Groups digits with a comma as a thousands separator.
• 7.1f: This ensures that the floating-point number takes at least 7 characters in total, with 1 decimal place.
• %1$s: It refers to the first argument i.e. "s" the unit and formats it as a string.

Java Format Specifiers

The String.format() method uses format specifiers to format various types of data. Below are some common specifiers: