How To Use printf() For Formatting Output in Java

As a Java developer, you must be familiar with System.out.println() statement for printing output to the console.
However, when it comes to formatting output, println() can be limited.
That’s where printf() comes in – a powerful method for formatting output with precision and flexibility.
In this tutorial, you will learn how to use printf() to format integers, strings, floating-point numbers, and more, as well as use its advanced features like flags, width, and precision specifiers.
By the end of this tutorial, you will learn how to use printf() in java for output formatting and make your Java programs more readable and user-friendly.

What is printf() in Java?

printf() is a method that allows you to format your output in a more controlled and flexible way.
It is similar to the C programming language’s printf() function, hence the name.

printf() method enables you to format your output by inserting values into a string template.
printf() method is part of the java.io.PrintStream class, which is why you often see it used with System.out, like this: System.out.printf().

printf() takes a format string and one or more arguments, and then prints the formatted string to the console.
The format string contains placeholders for the arguments, which are replaced with the actual values when the printf() method is called.

printf() syntax

Below is the definition of printf() defined in PrintStream class

public PrintStream printf(String format, Object ... args) {
  return format(format, args);
}

Here, format is a string that contains format specifiers, which are placeholders for the arguments that follow.
args is an array of the values that will be inserted into the format string at the corresponding format specifiers.

printf() example

Let’s say you want to print a message with a variable name and age. You can use printf() as below

String name = "John"; 
int age = 30; 
System.out.printf("My name is %s, I am %d years old.%n", name, age);

This would output

The %s and %d are format specifiers that indicate where the string and integer values should be inserted, respectively.
The %n at the end is a newline character, which moves the cursor to the next line.

As you can see, printf() offers more flexibility and control over your output compared to println(), which simply prints its argument without any formatting options. In the next chapters, we’ll explore the various format specifiers and features of printf() in more detail, so you can master the art of formatting output in Java.

printf() vs println()

Both println() and printf() print output to the console.
But they also have some differences.
One of the main differences between printf() and println() is that println() automatically appends a newline character (\n) to the end of the output, whereas printf() does not.

Another difference is that printf() allows you to specify format specifiers, which enable you to control the formatting of your output with precision.
For example, you can use the %d format specifier to print an integer value, or the %f format specifier to print a floating-point number with a specific number of decimal places.
println() does not offer this level of control over output formatting.

Format Specifiers in Java

Format specifiers are placeholders that are replaced with the actual values you want to print.

When you use printf(), you need to specify a format string that contains format specifiers.
The format specifiers are preceded by a percentage sign (%) and are followed by a conversion character that indicates the type of value you want to print.
For example, %d is used to print an integer, %s is used to print a string, and %f is used to print a floating-point number.

Here are some common format specifiers you’ll use in Java:

• %d: integer
• %s: string
• %f: floating-point number
• %c: character
• %b: boolean

Below is an example of using format specifiers with printf()

int age = 25; 
String name = "John"; 
double height = 5.8; 
System.out.printf("My name is %s, I am %d years old, "+  
                    "I am %.2f meters tall.", name, age, height);

In this example, the format string contains three format specifiers: %s, %d, and %f.
The values of the variables name, age, and height are inserted into the format string at the corresponding positions, resulting in the output

Formatting Floating-Point Numbers with printf()

For formatting floating-point numbers with printf() you will need to specify the format specifier, as well as the precision and width of the output.

In Java, the format specifier for floating-point numbers is %f.
You can use this specifier to print float and double values. For example:

double pi = 3.14159; 
System.out.printf("The value of pi is %.2f%n", pi);

In this example, the %.2f format specifier tells printf() to print the value of pi as a floating-point number with two decimal places.
The %n at the end of the format string is a newline character, which advances the cursor to the next line.

You can also specify the width of the output by adding a number before the precision specifier. For example:

double e = 2.71828; 
System.out.printf("The value of e is %10.3f%n", e);

In this example, the %10.3f format specifier tells printf() to print the value of e as a floating-point number with a width of 10 characters and three decimal places.

You can also use other format specifiers for floating-point numbers, such as %e or %g, depending on your specific needs. For example:

double largeNumber = 123456789.0; 
System.out.printf("The large number is %e%n", largeNumber);

In this example, the %e format specifier tells printf() to print the value of largeNumber in scientific notation.

Formatting Other Data Types with printf()

You can use printf() to format various data types, including characters, booleans, and more.
Here’s a list of the format specifiers you can use for these data types:

Data Type	Format Specifier
Character	%c
Boolean	%b
Long integer	%l or %ld
Double	%f or %lf
Short integer	%h or %hd
Hexadecimal Integer	%x or %X
Exponential notation	%e or %E

Using these format specifiers, you can create customized output for your programs.
For example, to print a character using printf(), you can use the following code:

char myChar = 'A'; 
System.out.printf("The character is %c", myChar);

This will output

Similarly, you can use the %b format specifier to print a boolean value:

boolean myBoolean = true; 
System.out.printf("The boolean value is %b", myBoolean);

This will output

printf() flags (e.g. -, +, 0) to customize output

Now let’s understand how to customize printf() output using flags.
Flags are modifiers that can be used to change the behavior of the format specifiers.

There are several flags you can use with printf(), including:

• – (minus sign): Left-justifies the output
• + (plus sign): Includes a plus sign (+) for positive numbers
• 0 (zero): Pads the output with zeros instead of spaces

Let’s see some examples of how you can use these flags to customize output.

If you want to left-justify a string, you can use the - flag:

System.out.printf("-%10s-\n", "Hello");

This will output:

Notice how the string “Hello” is left-justified within the 10-character field.

If you want to include a plus sign (+) for positive numbers, you can use the + flag:

System.out.printf("%+d\n", 42);

This will output:

Finally, if you want to pad a number with zeros instead of spaces, you can use the 0 flag:

System.out.printf("%04d\n", 42);

This will output:

0042

As you can see, using flags with printf() gives you more control over the output format. In the next section, we’ll explore how to use width and precision specifiers to further customize your output.

printf() width and precision specifiers

Width specifiers are used to specify the minimum field width of the output.
This means that if the output is shorter than the specified width, it will be padded with spaces to reach the desired width.
For example, if you want to print an integer with a minimum width of 5 characters, you can use the following code:

int num = 12; 
System.out.printf("%5d", num);

This will output ” 12″, with three spaces padding the output to reach a minimum width of 5 characters.

Precision specifiers, on the other hand, are used to specify the maximum number of characters to be printed for a particular output.
This is particularly useful when working with floating-point numbers, where you may want to limit the number of decimal places displayed.
For example, if you want to print a double with a maximum of 2 decimal places, you can use the following code:

double num = 12.3456; 
System.out.printf("%.2f", num);

This will output “12.35”, with the output rounded to 2 decimal places.

By combining width and precision specifiers, you can achieve even more precise control over the output of printf() statements.
For example, if you want to print a double with a minimum width of 10 characters and a maximum of 2 decimal places, you can use the following code:

double num = 12.3456; 
System.out.printf("%10.2f", num);

This will output ” 12.35″, with the output padded to a minimum width of 10 characters and rounded to 2 decimal places.

printf() common mistakes

A common mistake while using printf() is mismatching the format specifiers with the corresponding arguments.
For instance, if you use %d for formatting a string, you’ll get a runtime error.
Make sure to use the correct format specifier for each data type.

Another mistake is not considering the width and precision of the output.
If you don’t specify the width and precision correctly, your output might not be formatted as expected.
For example, if you want to format a floating-point number with two decimal places, you should use %.2f instead of just %f.

Here’s an example of incorrect formatting:

System.out.printf("The value is %f", 10.123456); 
// Output: The value is 10.123456

And the correct way to format it is

System.out.printf("The value is %.2f", 10.123456); 
// Output: The value is 10.12

Conclusion

Become proficient in using printf() in Java to overcome different formatting difficulties.
Practice using a variety of format specifiers to improve your skills and knowledge.