How to format String in Java – String format Example

String format and printf Example

How to format String in Java is the most common problem developers encounter because of classic System.out.println() doesn’t support formatting of String while printing on console. For those who don’t know What is formatted String? here is a simple definition,  Formatted String is a String that not only displays contents but also displays it in a format that is widely accepted like including comma while displaying large numbers e.g. 100,000,000, etc. Displaying formatted String is one of the needs for modern GUI applications and thankfully Java has good support for formatting String and all other types like Integers, Double, and Date. 

How to format a String in Java is never as easy as it has been since Java 1.5 which along with front line features like Generics, Enum, Autoboxing and Varargs also introduce several utility methods to support rich formatting of String in Java. 

Prior to Java 5 java programmer relies on java.text API for all their formatting need but with Java 5 we have now two more convenient ways to format String in Java. JDK 1.5 has added format() method in java.lang.String class and provided a printf() method in PrintStream class for printing formatted output in the console.

The printf() method is similar to the C programming language printf() method and allows a programmer to print formatting string directly to console, which makes System.out.printf() better alternative to System.out.println() method. Both format() and printf()  are overloaded method to support Locale specific formatting.

By the way, this is the third article about formatting in Java, earlier we have seen Decimal Format examples and DateFormat examples for formatting numbers and dates in Java.

How String.format()or printf()works in Java

String.format() and System.out.printf() both works similarly and if you see the signature of both methods they also accept variable arguments. Both take a minimum of two parameters, the first of them is formatting instruction, and the other was actual String or anything which needs to be formatted. Java formatting instructions are both powerful and flexible and allow you to generate formatted String in many different formats. 

It's worth to understand the format of "formatting instruction" to take full benefit of String.format() method because this is the only tricky part of String formatting especially if you have not used printf() in past.

 I have seen developers struggle to understand the formatting behavior because of a lack of knowledge of different formatting options available in Java. This is how we specify formatting instruction in Java:

String.format "%[argument number] [flags] [width] [.precision] type"

Now let's see what is the meaning of each part of formatting instruction. "%" is a special character in formatted String and it denotes the start of formatting instruction. String.format() can support multiple formatting instructions with multiple occurrences of "%" character in formatting instruction.

"argument number" is used to specify the correct argument in case multiple arguments are available for formatting. "flags" is another special formatting instruction that is used to print String in some specific format for example you can use the flag as "," to print comma on output. "width" formatting option denotes minimum number or character will be used in output but in case if a number is larger than the width then the full number will be displayed but if it's smaller in length then it will be padded with zero.

The "precision" is using for print floating point formatted String, by using precision you can specify how many decimals a floating point number will be displayed in formatted String. "type" is the only mandatory formatting option and must always come last in format String also input String which needs to be formatted must be with the same type specified in "type" parameter. 

For example, you can not input a floating point number if you have specified "type" as decimal integer "%d", that will result in an error. Now let's see an example of a String format() method to understand these formatting options better:

format ( "%,6.2f", 124.000)

In the above example of  String.format() method flag is a comma ",", width is 6 and precision is up to 2 decimal point and type is a float.

String format Example in Java

In this section, we will see different examples to format String in Java. We will see how we can format numbers and dates. Introduce decimal points and aligning number left or right etc. One of the common application of format() is to print leading zero in a number as shown in this Java program example:

/**
 * Java program to demonstrate How to format String in Java by using

 * format() method of String class and printf() method of OutputStream in Java.
 * String.format() is very powerful and not only can format String but numbers

 * and Date in Java
 *
 * @author Javin
 */
public class StringFormatExample{
 
    public static void main(String args[]){            
     
        //simple example of formatted string in Java

        //%d is used to format decimals like integers

        //position of argument is the order in which they appear in source String

          e.g here 40021 will replace the first %d and 3000 will replace the second %d.

        String formattedString = String.format("Order with OrdId : %d and Amount: %d is missing", 40021, 3000);       

      

 System.out.println(formattedString);

   
        System.out.printf("Order with OrdId : %d  and Amount: %d is missing \n", 40021, 3000);
     
        //%s is used to denote String arguments in formatted String
        String str = String.format("Hello %s", "Raj");
        System.out.println(str);
     
        //if argument is not convertible into specified data type than

 //Formatter will throw following java.util.IllegalFormatConversionException

        //e.g. specifying %d and passing 3.0
     
        //str = String.format("Number %d", 3.0);
     
//        Exception in thread "main" java.util.IllegalFormatConversionException: d != java.lang.Double
//      at java.util.Formatter$FormatSpecifier.failConversion(Formatter.java:3999)
//      at java.util.Formatter$FormatSpecifier.printInteger(Formatter.java:2709)
//      at java.util.Formatter$FormatSpecifier.print(Formatter.java:2661)
//      at java.util.Formatter.format(Formatter.java:2433)
//      at java.util.Formatter.format(Formatter.java:2367)
//      at java.lang.String.format(String.java:2769)
     
        //common meta characters used in String.format() and

 //System.out.printf() method: %s - String , %d - decimal integer

        // %f - float  %tD - date as MM/dd/yy while %td is day %tm is month

 // and %ty is 2 digit year while %tY is four digit year

     
        //Formatting date in String format method - date in MM/dd/yy
        str = String.format("Today is %tD", new Date());
        System.out.println(str);
     
        Date today = new Date();
        System.out.printf("Date in dd/mm/yy format %td/%tm/%ty %n", today,today,today );
     
        // date as July 25, 2012, difference between %td and %te is that

 // %td use leading zero while %te doesn't
        System.out.printf("Today is %tB %te, %tY %n", today,today,today,today);
     
        //adding leading zero in numbers using String format,

 //%d is for decimal, 8 specify formatted number should be 8 digits and 0 specify use
        //leading zero, default is space, so if you don't specify leading

 // character space will be used.
        System.out.printf("Amount : %08d %n" , 221);
     
        //printing positive and negative number using String format

 //+ sign for positive, - for negative and %n is for new line

        System.out.printf("positive number : +%d %n", 1534632142);
        System.out.printf("negative number : -%d %n", 989899);
     
        //printing floating point number with System.format()
        System.out.printf("%f %n", Math.E);
     
        //3 digit after decimal point
        System.out.printf("%.3f %n", Math.E);
     
        //8 charcter in width and 3 digit after decimal point
        System.out.printf("%8.3f %n", Math.E);
     
        //adding comma into long numbers
        System.out.printf("Total %,d messages processed today", 10000000);
    }
 
 
}

Output:
Order with OrdId: 40021  and Amount: 3000 is missing
Order with OrdId: 40021  and Amount: 3000 is missing
Hello Raj
Today is 07/25/12
Date in dd/mm/yy format 25/07/12
Today is July 25, 2012
Amount: 00000221
positive number: +1534632142
negative number : -989899n
2.718282
2.718
   2.718
Total 10,000,000 messages processed today

Difference between the printf and format methods in Java

printf() and format()both methods are used to format String in Java and are more or less similar. printf()is more close to the C programming language because of the identical name used in the C programming language, Anyone who has work in C previously can easily start with this printf() method also its look more like a replacement of System.out.println(). 

if you don't want to print just want a formatted string for any other purpose String format() method is a way to go. In summary, you can say that printf()writes to stdout while format() return you a formatted string.

We have already seen String format examples with both format and printf methods. In short, formatting is easier in Java and it provides several classes like DateFormat, NumberFormat, etc which can also be used to format Date and numbers.

Other Java String related posts from Javarevisited, you may like:

How substring works in Java

How to replace String in Java using regular expression

Why Character array is better than String for storing passwords in Java

How to convert String to Integer in Java

How to convert String into dd-mm-yy date with example

How to split String with 2 examples in Java

How to compare two String in Java