Format Specifiers in Java

06 Jul, 2020
Format specifiers begin with a percent character (%) and terminate with a “type character, ” which indicates the type of data (int, float, etc.) that will be converted the basic manner in which the data will be represented (decimal, hexadecimal, etc.)The general syntax of a format specifier is
% [flags] [width] [.precision] [argsize] typechar
The format() method of Formatter class accepts a wide variety of format specifiers. When an uppercase specifier is used, then letters are shown in uppercase. Otherwise, the upper- and lowercase specifiers perform the same conversion.
Space format specifier : When creating columns of numbers, it is sometimes very useful to print a space before a positive number so that positive and negative number get aligned. To do this, space format specifier can be used.Syntax:Formatter().format("% d", -111);
Formatter().format("% d", 111);

Output:
-111
 111
Example:// Java program to demonstrate// the space format specifier  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // Use Space format specifier        formatter.format("%d", -111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", 111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", -222);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", 222);        System.out.println(formatter);    }}Output:-111
 111
-222
 222
+ Sign Specifier: This adds the + sign before positive numeric value, and has no effect on negative numeric value.Syntax:Formatter().format("%+d", 111);

Output:
+111
Example:// Java program to demonstrate// the + sign Specifier format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // + sign specifier        formatter = new Formatter();        formatter.format("%+d", 111);        System.out.println(formatter);          // + sign specifier        // on - sign, it will have no effect        formatter = new Formatter();        formatter.format("%+d", -111);        System.out.println(formatter);    }}Output:+111
-111
( specifier: This specifier puts the negative numeric values inside the parentheses, and has no effect on the positive numeric values.Syntax:Formatter().format("%(d", -111);
Formatter().format("%(d", 111);

Output:
(111)
111
Example:// Java program to demonstrate// the ( Specifiers format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // ( Specifier        formatter = new Formatter();        formatter.format("%(d", -111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("%(d", 111);        System.out.println(formatter);    }}Output:(111)
111
Comma, Specifier: For displaying large numbers, it is often useful to add grouping separators by comma (, ). For example, the value is 1000000 more easily read when formatted as 1, 000, 000. To add grouping specifiers (, ) use the comma(, ) Specifier.Syntax:Formatter().format("%, d", 1000000);

Output:
1, 000, 000Example:// Java program to demonstrate// the comma format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // comma Specifier        formatter = new Formatter();        formatter.format("%, d", 1000000);        System.out.println(formatter);          // comma Specifier        formatter = new Formatter();        formatter.format("%, .3f", 32659526566.4521);        System.out.println(formatter);    }}Output:1, 000, 000
32, 659, 526, 566.452
Left Justification(-) Specifier: By default all output is right-shifted. That is, if the field width is longer than the data printed, data will be placed on the right side of the field. One can force output to be left-justified by placing a minus sign directly after the %. For instance, %-20.4f left justifies a floating-point number with two decimal places in a 20-character field.Syntax:Formatter().format("|%-20.4f|", 1234.1234);

Output:
|           1234.1234|
|1234.1234           |
Example:// Java program to demonstrate// the left justification format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // right justify by default        formatter = new Formatter();        formatter.format("|%20.4f|", 1234.1234);        System.out.println(formatter);          // left justify        formatter = new Formatter();        formatter.format("|%-20.4f|", 1234.1234);        System.out.println(formatter);    }}Output:|           1234.1234|
|1234.1234           |
The %n format specifiers:The %n format specifier is different from the others in that it doesn’t take arguments. It is simply an escape sequence that inserts a character into the output. The %n inserts a newline. It can’t be entered directly into the format string.// Java program to demonstrate// the newline %n format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // newline format specifier        formatter.format("Geeks %nFor %nGeeks");          // Print the output        System.out.println(formatter);    }}Output:Geeks 
For 
Geeks
The %% format specifiers:The %% format specifier is different from the others in that it doesn’t take arguments. It is simply an escape sequence that inserts a character into the output. The %% inserts a % sign. It can’t be entered directly into the format string.// Java program to demonstrate// the %% format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %% format specifier        formatter.format("10 %% 4 = 2");          // Print the output        System.out.println(formatter);    }}Output:10 % 4 = 2
The %x %X format specifiers:The %x or %X format specifier is is used to represent the integer Hexadecimal value. %x displays the hexadecimal values with lowercase alphabets whereas the %X specifier displays the hexadecimal values with uppercase alphabets.// Java program to demonstrate// the integer-Hexadecimal %x and %X// format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %x format specifier        // It prints the number in Hexadecimal        // with lowercase alphabets        formatter.format("%x", 250);          // Print the output        System.out.println("LowerCase Hexadecimal"                           + " using %x: "                           + formatter);          // %X format specifier        // It prints the number in Hexadecimal        // with uppercase alphabets        formatter = new Formatter();        formatter.format("%X", 250);          // Print the output        System.out.println("UpperCase Hexadecimal"                           + " using %X: "                           + formatter);    }}Output:LowerCase Hexadecimal using %x: fa
UpperCase Hexadecimal using %X: FA
The %e %E format specifiers:The %e or %E format specifier is is used to represent the Scientific Notation of a value. %e displays the Scientific Notation with lowercase alphabets whereas the %E specifier displays the Scientific Notation with uppercase alphabets.// Java program to demonstrate// the Scientific Notation %e and %E// format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %e format specifier        // It prints the number in Scientific Notation        // with lowercase alphabets        formatter.format("%e", 123.1234);          // Print the output        System.out.println("LowerCase Scientific Notation"                           + " using %e: "                           + formatter);          // %E format specifier        // It prints the number in Scientific Notation        // with uppercase alphabets        formatter = new Formatter();        formatter.format("%E", 123.1234);          // Print the output        System.out.println("UpperCase Scientific Notation"                           + " using %E: "                           + formatter);    }}Output:LowerCase Scientific Notation using %e: 1.231234e+02
UpperCase Scientific Notation using %E: 1.231234E+02
Precision FormatsA precision specifier can be applied to the %f, %e, %g, and %s format specifiers.// Java program to demonstrate// Prrecision Format specifiers  import java.util.Formatter;  public class GFG {    public static void main(String args[])    {          // Create the Formatter instance        Formatter formatter = new Formatter();          // added floating-point data        // using the %f or %e specifiers,        // Format to 2 decimal places        // in a 16 character field.        formatter = new Formatter();        formatter.format("%16.2e", 123.1234567);        System.out.println("Scientific notation to 2 places: "                           + formatter);          // Format 4 decimal places.        formatter = new Formatter();        formatter.format("%.4f", 123.1234567);        System.out.println("Decimal floating-point"                           + " notation to 4 places: "                           + formatter);          // Format 4 places.        // The %g format specifier causes Formatter        // to use either %f or %e, whichever is shorter        formatter = new Formatter();        formatter.format("%.4g", 123.1234567);        System.out.println("Scientific or Decimal floating-point "                           + "notation to 4 places: "                           + formatter);          // Display at most 15 characters in a string.        formatter = new Formatter();        formatter.format("%.15s", "12345678901234567890");        System.out.println("String notation to 15 places: "                           + formatter);          // Format into 10 digit        formatter = new Formatter();        formatter.format("%010d", 88);        System.out.println("value in 10 digits: "                           + formatter);    }}Output:Scientific notation to 2 places:         1.23e+02
Decimal floating-point notation to 4 places: 123.1235
Scientific or Decimal floating-point notation to 4 places: 123.1
String notation to 15 places: 123456789012345
value in 10 digits: 0000000088

Space format specifier : When creating columns of numbers, it is sometimes very useful to print a space before a positive number so that positive and negative number get aligned. To do this, space format specifier can be used.Syntax:Formatter().format("% d", -111);
Formatter().format("% d", 111);

Output:
-111
 111
Example:// Java program to demonstrate// the space format specifier  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // Use Space format specifier        formatter.format("%d", -111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", 111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", -222);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", 222);        System.out.println(formatter);    }}Output:-111
 111
-222
 222

Syntax:
Formatter().format("% d", -111);
Formatter().format("% d", 111);

Output:
-111
 111

Example:
// Java program to demonstrate// the space format specifier  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // Use Space format specifier        formatter.format("%d", -111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", 111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", -222);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("% d", 222);        System.out.println(formatter);    }}
-111
 111
-222
 222

+ Sign Specifier: This adds the + sign before positive numeric value, and has no effect on negative numeric value.Syntax:Formatter().format("%+d", 111);

Output:
+111
Example:// Java program to demonstrate// the + sign Specifier format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // + sign specifier        formatter = new Formatter();        formatter.format("%+d", 111);        System.out.println(formatter);          // + sign specifier        // on - sign, it will have no effect        formatter = new Formatter();        formatter.format("%+d", -111);        System.out.println(formatter);    }}Output:+111
-111

Syntax:
Formatter().format("%+d", 111);

Output:
+111

Example:
// Java program to demonstrate// the + sign Specifier format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // + sign specifier        formatter = new Formatter();        formatter.format("%+d", 111);        System.out.println(formatter);          // + sign specifier        // on - sign, it will have no effect        formatter = new Formatter();        formatter.format("%+d", -111);        System.out.println(formatter);    }}
+111
-111

( specifier: This specifier puts the negative numeric values inside the parentheses, and has no effect on the positive numeric values.Syntax:Formatter().format("%(d", -111);
Formatter().format("%(d", 111);

Output:
(111)
111
Example:// Java program to demonstrate// the ( Specifiers format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // ( Specifier        formatter = new Formatter();        formatter.format("%(d", -111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("%(d", 111);        System.out.println(formatter);    }}Output:(111)
111

Syntax:
Formatter().format("%(d", -111);
Formatter().format("%(d", 111);

Output:
(111)
111

Example:
// Java program to demonstrate// the ( Specifiers format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // ( Specifier        formatter = new Formatter();        formatter.format("%(d", -111);        System.out.println(formatter);          formatter = new Formatter();        formatter.format("%(d", 111);        System.out.println(formatter);    }}
(111)
111

Comma, Specifier: For displaying large numbers, it is often useful to add grouping separators by comma (, ). For example, the value is 1000000 more easily read when formatted as 1, 000, 000. To add grouping specifiers (, ) use the comma(, ) Specifier.Syntax:Formatter().format("%, d", 1000000);

Output:
1, 000, 000Example:// Java program to demonstrate// the comma format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // comma Specifier        formatter = new Formatter();        formatter.format("%, d", 1000000);        System.out.println(formatter);          // comma Specifier        formatter = new Formatter();        formatter.format("%, .3f", 32659526566.4521);        System.out.println(formatter);    }}Output:1, 000, 000
32, 659, 526, 566.452

Syntax:
Formatter().format("%, d", 1000000);

Output:
1, 000, 000
Example:
// Java program to demonstrate// the comma format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // comma Specifier        formatter = new Formatter();        formatter.format("%, d", 1000000);        System.out.println(formatter);          // comma Specifier        formatter = new Formatter();        formatter.format("%, .3f", 32659526566.4521);        System.out.println(formatter);    }}
1, 000, 000
32, 659, 526, 566.452

Left Justification(-) Specifier: By default all output is right-shifted. That is, if the field width is longer than the data printed, data will be placed on the right side of the field. One can force output to be left-justified by placing a minus sign directly after the %. For instance, %-20.4f left justifies a floating-point number with two decimal places in a 20-character field.Syntax:Formatter().format("|%-20.4f|", 1234.1234);

Output:
|           1234.1234|
|1234.1234           |
Example:// Java program to demonstrate// the left justification format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // right justify by default        formatter = new Formatter();        formatter.format("|%20.4f|", 1234.1234);        System.out.println(formatter);          // left justify        formatter = new Formatter();        formatter.format("|%-20.4f|", 1234.1234);        System.out.println(formatter);    }}Output:|           1234.1234|
|1234.1234           |

Syntax:
Formatter().format("|%-20.4f|", 1234.1234);

Output:
|           1234.1234|
|1234.1234           |

Example:
// Java program to demonstrate// the left justification format specifiers.  import java.util.*;  class GFG {    public static void main(String args[])    {          // create Formatter class object        Formatter formatter = new Formatter();          // right justify by default        formatter = new Formatter();        formatter.format("|%20.4f|", 1234.1234);        System.out.println(formatter);          // left justify        formatter = new Formatter();        formatter.format("|%-20.4f|", 1234.1234);        System.out.println(formatter);    }}
|           1234.1234|
|1234.1234           |

The %n format specifiers:The %n format specifier is different from the others in that it doesn’t take arguments. It is simply an escape sequence that inserts a character into the output. The %n inserts a newline. It can’t be entered directly into the format string.// Java program to demonstrate// the newline %n format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // newline format specifier        formatter.format("Geeks %nFor %nGeeks");          // Print the output        System.out.println(formatter);    }}Output:Geeks 
For 
Geeks

// Java program to demonstrate// the newline %n format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // newline format specifier        formatter.format("Geeks %nFor %nGeeks");          // Print the output        System.out.println(formatter);    }}
Geeks 
For 
Geeks

The %% format specifiers:The %% format specifier is different from the others in that it doesn’t take arguments. It is simply an escape sequence that inserts a character into the output. The %% inserts a % sign. It can’t be entered directly into the format string.// Java program to demonstrate// the %% format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %% format specifier        formatter.format("10 %% 4 = 2");          // Print the output        System.out.println(formatter);    }}Output:10 % 4 = 2

// Java program to demonstrate// the %% format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %% format specifier        formatter.format("10 %% 4 = 2");          // Print the output        System.out.println(formatter);    }}
10 % 4 = 2

The %x %X format specifiers:The %x or %X format specifier is is used to represent the integer Hexadecimal value. %x displays the hexadecimal values with lowercase alphabets whereas the %X specifier displays the hexadecimal values with uppercase alphabets.// Java program to demonstrate// the integer-Hexadecimal %x and %X// format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %x format specifier        // It prints the number in Hexadecimal        // with lowercase alphabets        formatter.format("%x", 250);          // Print the output        System.out.println("LowerCase Hexadecimal"                           + " using %x: "                           + formatter);          // %X format specifier        // It prints the number in Hexadecimal        // with uppercase alphabets        formatter = new Formatter();        formatter.format("%X", 250);          // Print the output        System.out.println("UpperCase Hexadecimal"                           + " using %X: "                           + formatter);    }}Output:LowerCase Hexadecimal using %x: fa
UpperCase Hexadecimal using %X: FA

// Java program to demonstrate// the integer-Hexadecimal %x and %X// format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %x format specifier        // It prints the number in Hexadecimal        // with lowercase alphabets        formatter.format("%x", 250);          // Print the output        System.out.println("LowerCase Hexadecimal"                           + " using %x: "                           + formatter);          // %X format specifier        // It prints the number in Hexadecimal        // with uppercase alphabets        formatter = new Formatter();        formatter.format("%X", 250);          // Print the output        System.out.println("UpperCase Hexadecimal"                           + " using %X: "                           + formatter);    }}
LowerCase Hexadecimal using %x: fa
UpperCase Hexadecimal using %X: FA

The %e %E format specifiers:The %e or %E format specifier is is used to represent the Scientific Notation of a value. %e displays the Scientific Notation with lowercase alphabets whereas the %E specifier displays the Scientific Notation with uppercase alphabets.// Java program to demonstrate// the Scientific Notation %e and %E// format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %e format specifier        // It prints the number in Scientific Notation        // with lowercase alphabets        formatter.format("%e", 123.1234);          // Print the output        System.out.println("LowerCase Scientific Notation"                           + " using %e: "                           + formatter);          // %E format specifier        // It prints the number in Scientific Notation        // with uppercase alphabets        formatter = new Formatter();        formatter.format("%E", 123.1234);          // Print the output        System.out.println("UpperCase Scientific Notation"                           + " using %E: "                           + formatter);    }}Output:LowerCase Scientific Notation using %e: 1.231234e+02
UpperCase Scientific Notation using %E: 1.231234E+02

// Java program to demonstrate// the Scientific Notation %e and %E// format specifiers.  import java.util.*;  public class GFG {    public static void main(String args[])    {        // create Formatter class object        Formatter formatter = new Formatter();          // %e format specifier        // It prints the number in Scientific Notation        // with lowercase alphabets        formatter.format("%e", 123.1234);          // Print the output        System.out.println("LowerCase Scientific Notation"                           + " using %e: "                           + formatter);          // %E format specifier        // It prints the number in Scientific Notation        // with uppercase alphabets        formatter = new Formatter();        formatter.format("%E", 123.1234);          // Print the output        System.out.println("UpperCase Scientific Notation"                           + " using %E: "                           + formatter);    }}
LowerCase Scientific Notation using %e: 1.231234e+02
UpperCase Scientific Notation using %E: 1.231234E+02

Precision FormatsA precision specifier can be applied to the %f, %e, %g, and %s format specifiers.// Java program to demonstrate// Prrecision Format specifiers  import java.util.Formatter;  public class GFG {    public static void main(String args[])    {          // Create the Formatter instance        Formatter formatter = new Formatter();          // added floating-point data        // using the %f or %e specifiers,        // Format to 2 decimal places        // in a 16 character field.        formatter = new Formatter();        formatter.format("%16.2e", 123.1234567);        System.out.println("Scientific notation to 2 places: "                           + formatter);          // Format 4 decimal places.        formatter = new Formatter();        formatter.format("%.4f", 123.1234567);        System.out.println("Decimal floating-point"                           + " notation to 4 places: "                           + formatter);          // Format 4 places.        // The %g format specifier causes Formatter        // to use either %f or %e, whichever is shorter        formatter = new Formatter();        formatter.format("%.4g", 123.1234567);        System.out.println("Scientific or Decimal floating-point "                           + "notation to 4 places: "                           + formatter);          // Display at most 15 characters in a string.        formatter = new Formatter();        formatter.format("%.15s", "12345678901234567890");        System.out.println("String notation to 15 places: "                           + formatter);          // Format into 10 digit        formatter = new Formatter();        formatter.format("%010d", 88);        System.out.println("value in 10 digits: "                           + formatter);    }}Output:Scientific notation to 2 places:         1.23e+02
Decimal floating-point notation to 4 places: 123.1235
Scientific or Decimal floating-point notation to 4 places: 123.1
String notation to 15 places: 123456789012345
value in 10 digits: 0000000088

// Java program to demonstrate// Prrecision Format specifiers  import java.util.Formatter;  public class GFG {    public static void main(String args[])    {          // Create the Formatter instance        Formatter formatter = new Formatter();          // added floating-point data        // using the %f or %e specifiers,        // Format to 2 decimal places        // in a 16 character field.        formatter = new Formatter();        formatter.format("%16.2e", 123.1234567);        System.out.println("Scientific notation to 2 places: "                           + formatter);          // Format 4 decimal places.        formatter = new Formatter();        formatter.format("%.4f", 123.1234567);        System.out.println("Decimal floating-point"                           + " notation to 4 places: "                           + formatter);          // Format 4 places.        // The %g format specifier causes Formatter        // to use either %f or %e, whichever is shorter        formatter = new Formatter();        formatter.format("%.4g", 123.1234567);        System.out.println("Scientific or Decimal floating-point "                           + "notation to 4 places: "                           + formatter);          // Display at most 15 characters in a string.        formatter = new Formatter();        formatter.format("%.15s", "12345678901234567890");        System.out.println("String notation to 15 places: "                           + formatter);          // Format into 10 digit        formatter = new Formatter();        formatter.format("%010d", 88);        System.out.println("value in 10 digits: "                           + formatter);    }}
Scientific notation to 2 places:         1.23e+02
Decimal floating-point notation to 4 places: 123.1235
Scientific or Decimal floating-point notation to 4 places: 123.1
String notation to 15 places: 123456789012345
value in 10 digits: 0000000088

Related Article : Format Specifiers in C
Akanksha_Rai
gowtham_yuvaraj
ritudpande
Java-Output
Java-Strings
Technical Scripter 2018
Java
Technical Scripter
Java-Strings
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Object Oriented Programming (OOPs) Concept in Java
How to iterate any Map in Java
Interfaces in Java
HashMap in Java with Examples
ArrayList in Java
Stream In Java
Collections in Java
Multidimensional Arrays in Java
Singleton Class in Java
Set in Java