Format Specifiers in Java
Last Updated :
17 Aug, 2022
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.
| Format Specifier | Conversion Applied |
|---|
| %% | Inserts a % sign |
|---|
| %x %X | Integer hexadecimal |
|---|
| %t %T | Time 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 |
|---|
- 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
// 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);
}
}
- + 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
// 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);
}
}
- ( 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
// 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);
}
}
- 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:
JAVA
// 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
// 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
// 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);
}
}
- 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
// 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);
}
}
- The %x %X format specifiers: The %x or %X format specifier 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
// 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 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
// 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 Formats A precision specifier can be applied to the %f, %e, %g, and %s format specifiers.
JAVA
// Java program to demonstrate
// Precision 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
Related Article : Format Specifiers in C
Similar Reads
HexFormat in Java HexFormat is a mechanism that can convert bytes to hexadecimal strings and vice versa. It can add extra formatting such as symbols, commas, or brackets to the output. Two versions of HexFormat can be used, one with a specific symbol and one without any symbols. Other options can be set using various
5 min read
YearMonth format() method in Java The format() method of YearMonth class in Java is used to format this YearMonth instance according to a specified DateTimeFormatter for year-month passed as parameter to this method. Syntax: public String format(DateTimeFormatter formatter) Parameter: This method accepts a single parameter formatter
1 min read
Important Keywords in Java Keywords refer to the reserved set of words of a language. These are used for some predefined actions. abstract: It is a non-access modifier applicable for classes and methods. It is used to achieve abstraction. For more, refer to abstract keyword in javaenum: It is used to define enum in Javainstan
2 min read
dot(.) Operator in Java The dot (.) operator is one of the most frequently used operators in Java. It is essential for accessing members of classes and objects, such as methods, fields, and inner classes. This article provides an in-depth look at the dot operator, its uses, and its importance in Java programming.Dot(.) Ope
4 min read
Formatted Output in Java using printf() Sometimes in programming, it is essential to print the output in a given specified format. Most users are familiar with the printf function in C. Let us discuss how we can Formatting Output with printf() in Java in this article.Formatting Using Java Printf()printf() uses format specifiers for format
5 min read
DecimalFormat setPositiveSuffix() method in Java The setPositiveSuffix() method of the DecimalFormat class in Java is used to set a positive suffix value for this DecimalFormat instance. Syntax: public void setPositiveSuffix(String newValue) Parameters: This method a single parameter newValue which is the new value to be set as a positive suffix f
1 min read
DecimalFormat setPositivePrefix() method in Java The setPositivePrefix() method of the DecimalFormat class in Java is used to set a positive prefix value for this DecimalFormat instance. Syntax: public void setPositivePrefix(String newValue) Parameters: This method a single parameter newValue which is the new value to be set as a positive prefix f
1 min read
Literals in Java In Java, a Literal is a synthetic representation of boolean, numeric, character, or string data. It is a medium of expressing particular values in the program, such as an integer variable named "x" is assigned an integer value in the following statement.// Here 100 is a constant/literal.int x = 100;
6 min read
Year format() method in Java with Examples The format() method of Year class in Java is used to format the current Year object according to the DateTimeFormatter passed to it as a parameter. Syntax: public String format(DateTimeFormatter formatter) Parameter: This method accepts a single parameter formatter. It specifies a DateTimeFormatter
2 min read
Compare two Strings in Java String in Java are immutable sequences of characters. Comparing strings is the most common task in different scenarios such as input validation or searching algorithms. In this article, we will learn multiple ways to compare two strings in Java with simple examples.Example:To compare two strings in
4 min read