The Java String format() method is used for formatting strings. Similar to the printf() method, the format() method comes with a range of format specifiers and sub-specifiers that give developers a comprehensive option list to choose from when displaying data. Unlike the printf() method, the format() method output can be stored in a string variable for use in other parts of your application like a GUI text field or started for use later.

The Java String format() method uses a specified locale (n object which represents a specific geographical, political, or cultural region), format string, and object arguments. The local is not required, however the format string and object argument are required.

There are two general syntax options for the format() method:

1. String.format(locale, String format, Object… args);
2. String.format(String format, Object… args);

Let’s break this down:

• String is the class that contains the format() method.
• format() is a static method that is called using the class name String.
• locale is optional and specifies a geographical location.
• String format is a string that is to be formatted.
• Object… args means more than one object can be passed to format().

Data from the additional args is formatted and written into placeholders marked by a % symbol. The argument formatting is dependent on the sequence of characters that follow the % symbol. The placeholders have the form:

%[arg$][flags][width][.precision]conversion

The components in [square brackets] are optional and the options are:

• arg$ is optional. A number followed by a $ sign which indicates which of the additional arguments to use, argument numbers start at 1. This can be replaced with a < which specifies that the argument from the previous placeholder should be used.
• flags is optional. A sequence of any of the following characters:
  • – Makes the output left-justified by adding any padding spaces to the right instead of to the left.
  • # Shows an alternate representation of the formatted data depending on the conversion.
  • + Causes positive numbers to always be prefixed with “+”.
  •  (A space character) This prefixes a space to positive numbers, primarily so that the digits can be lined up with the digits of negative numbers.
  • 0 Pads numbers with zeroes on the left.
  • , Groups digits (for example by thousands) and puts separators between the groups. This is affected by the locale.
  • ( Encloses negative numbers in parentheses.
  • width is optional. A whole number specifying the minimum number of characters that the output should occupy. If necessary spaces are added to the right to reach this number, or to the left if the – flag is used.
  • .precision is optional. A . followed by a whole number indicating how many decimal digits to show in the formatted data.
  • conversion is required. A character which indicates how an argument’s data should be represented. If the character is uppercase the data will be formatted in uppercase where possible. The list of possible characters is shown in the table below.

1. String.format(locale, String format, Object… args);

Use this option if you require formatting that has geographical, political, or cultural significance. For example, characters that represent a decimal differ around the world. In the US, UK and Ireland, a (decimal) point or dot is used; 123.99. In some European countries, a comma is used to represent a decimal: 123,99.

Use Java’s Locale to format an output to account for geographical differences. Note that If a locale is not passed to this method then the locale given by Locale.getDefault() is used.

String FR = String.format(Locale.FRANCE, "version is %f ",123.99);
String US = String.format(Locale.US, "version is %f  ",123.99);
System.out.println("The FR " + FR);
System.out.println("The US " + US);

Notice the difference in decimal character in the output below. The French decimal character is a comma whereas the US uses a point:

run:
The FR version is 123,990000 
The US version is 123.990000

We can see that the println() method uses a string concatenated with a variable which is a typical use of that method.

System.out.println(“The FR ” + FR);

The format() method is used to format a string that, in this case, we are assigning to a string variable.

String FR = String.format(Locale.FRANCE, “version is %f “,123.99);

This format() method has three parts:

1. locale
2. format
3. argument

The first part is the locale and we have discussed that earlier. The second part contains a format specifier that will dictate how the third part will be formatted.

String.format(Locale.US, “version is %f “,123.99);

How does this work exactly:

• String.format has an argument contained within round brackets as follows:
• The locale will change anything that varies by region (for example the way most countries in Europe use a comma for decimals but the US, UK and Ireland use a full stop or period).
• A comma separates locale from the next part of the argument.
• The % character is a placeholder and acts like a flag that Java will pay attention to.
• The letter after the % character (in this case f for float) will determine how and what Java will place at that point in the outputted string.
• A comma separates the string from the next part of the argument
• Finally, the data (in this case 123.99) that will replace the % symbol and its character ends the argument.

This is a simple example, you can have more complex strings with multiple data pieces.

2. String.format(String format, Object… args);

Let’s leave Locale behind and focus on String format, Object… args. Refer back to the placeholder list and conversion table above. These will give you precise instructions to format virtually any output. Let’s illustrate this with a few examples:

Here we have three values: a string “euro”, a number 1900000.49662, and another string “Your balance is”.

The challenge is to format the number to a more readable format using commas to separate thousands and limit the decimal places to 2. We also need to rearrange the data to present the values in a more coherent way so that the output reads “Your balance is 1,900,000.50 euro”.

Here’s the solution:

String output = String.format("%3$s %2$,3.2f %1$s", "euro", 1900000.49662, "Your balance is");
System.out.println(output);

This is how each part of the placeholder %3$s %2$,3.2f %1$s works:

• 3$ indicates that the first argument should be presented last (“euro”)
• s indicates that the first argument is a string (“euro”)
• 2$ indicates that the value of the second argument is used next (1900000.4966)
• , indicates that digits should be grouped by thousands (1,900,000.4966)
• 3 indicates that the representation of the data should be at least 3 characters long
• .2 indicates that there should be two digits after the decimal point
• f indicates that the data is being represented as a floating point number
• 1$ indicates that the third argument should be presented first
• s indicates that the third argument is a string

The output is:

Run:
Your balance is 1,900,000.50 euro
BUILD SUCCESS

**INCOMPLETE 240611**