Format Specifiers in Java

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.)
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.

Format Specifier Conversion Applied
%% Inserts a % sign
%x %X Integer hexadecimal
%t %T Dime and Date
%s %S String
%n Inserts a newline character
%o Octal integer
%f Decimal floating-point
%e %E Scientific notation
%g Causes Formatter to use either %f or %e, whichever is shorter
%h %H Hash code of the argument
%d Decimal integer
%c Character
%b %B Boolean
%a %A Floating-point hexadecimal
  1. Space format specifier : When creating columns of numbers, it is sometimes very useful to print a space before 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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    -111
     111
    -222
     222
    
  2. + 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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    +111
    -111
    
  3. ( 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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    (111)
    111
    
  4. 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, 000

    Example:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    1, 000, 000
    32, 659, 526, 566.452
    
  5. 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 the 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:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    |           1234.1234|
    |1234.1234           |
    
  6. 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 the output. The %n inserts a newline. It can’t be entered directly into the format string.

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    Geeks 
    For 
    Geeks
    
  7. 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 the output. The %% inserts a % sign. It can’t be entered directly into the format string.

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    10 % 4 = 2
    
  8. 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.

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    LowerCase Hexadecimal using %x: FA
    UpperCase Hexadecimal using %X: FA
    
  9. 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.

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    LowerCase Scientific Notation using %e: 1.231234e+02
    UpperCase Scientific Notation using %E: 1.231234E+02
    
  10. Precision Formats
    A precision specifier can be applied to the %f, %e, %g, and %s format specifiers.

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    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
    

Related Article : Format Specifiers in C



My Personal Notes arrow_drop_up

Strategy Path planning and Destination matters in success No need to worry about in between temporary failures

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.