Curriculum

Java Basic

Java Home

0/1

Java Introduction

0/1

Java Get Started

0/1

Java Syntax

0/1

Java Output / Print

0/2

Java Comments

0/1

Java Variables

0/5

Java Data Types

0/6

Java Type Casting

0/1

Java Operators

0/1

Java Strings

0/4

Java Math

0/1

Java Booleans

0/1

Java If ... Else

0/5

Java Switch

0/1

Java While Loop

0/3

Java For Loop

0/4

Java Break / Continue

0/1

Java Arrays

0/4

Java Methods

0/6

Java Classes

0/26

Java file Handling

0/4

Java How To

0/16

Java Reference

0/53

Java String Methods

0/39

Java Math Methods

0/48

Java Output Methods

0/4

Java Arrays Methods

0/6

Java ArrayList Methods

0/26

Java LinkedList Methods

0/27

Java HashMap Methods

0/23

Java Errors and Exception

0/1

Text lesson

format()

Example

Produce a string in a specified format.

String myStr = "Hello %s! One kilobyte is %,d bytes.";
String result = String.format(myStr, "World", 1024);
System.out.println(result);

Definition and Usage

The format() method generates a formatted string utilizing a locale, format, and extra arguments.

If no locale is specified, it defaults to the locale provided by Locale.getDefault().

The data provided in the additional arguments is formatted and inserted into the placeholders within the format string, denoted by the % symbol. The formatting of arguments is determined by the characters following the % symbol.

Placeholders

The placeholders follow the format %[arg$][flags][width][.precision]conversion, where the components within [square brackets] are optional.

Each component can be explained as follows:

arg$: Optional. It denotes a number followed by a $ sign, indicating which additional argument to use. Argument numbers start at 1. This can be replaced with <, specifying that the argument from the previous placeholder should be used.
Flags – Optional. A sequence of any of the following characters:

-: Left-justifies the output by adding padding spaces to the right instead of the left.

#: Displays an alternate representation of the formatted data based on the conversion.

+: Prefixes positive numbers with a “+”.

:(A space character): Prefixes positive numbers with a space, aligning them with negative numbers.

0: Pads numbers with zeroes on the left.

,: Groups digits (e.g., by thousands) with separators, influenced by the locale.

(: Encloses negative numbers in parentheses.

width: Optional. It denotes a whole number specifying the minimum number of characters the output should occupy. If necessary, spaces are added to reach this number, or to the left if the – flag is used.
precision: Optional. It consists of a dot followed by a whole number, indicating how many decimal digits to show in the formatted data.
conversion: Required. It is a character indicating how an argument’s data should be represented. If the character is uppercase, the data will be formatted in uppercase where possible. The possible characters are detailed in the table below.

List of conversions

Character	Conversion	Description
%	percent	Render a literal “%” character in the output.
n	line break	Indicates a line break in the output
b/B	boolean	Outputs the boolean value of an argument as “true” or “false”. When “B” is specified, it displays “TRUE” or “FALSE” instead.
h/H	Unsigned hexadecimal integer	Represents the binary data of an argument as an unsigned hexadecimal integer. When “H” is utilized, digits A to F are displayed in uppercase. Note: This representation does not accurately reflect the real value for any data other than positive integers.
s/S	String	“Shows the standard string representation of the input. If ‘S’ is specified, the string will be converted to uppercase whenever feasible.”
c/C	Unicode character	“Shows the Unicode character representation of the input. For integers, this represents the Unicode character corresponding to the number. If ‘C’ is specified, the character will be converted to uppercase whenever feasible.”
d	Decimal integer	“Represents an integer as a decimal whole number.”
o	Octal integer	“Represents an integer as an octal number. Using the “#” flag will add a “0” prefix to the number.”
x/x	Hexadecimal integer	“Represents an integer as a hexadecimal number. When the “#” flag is used, the number is prefixed with ‘0x’. If ‘X’ is specified, digits A to F and the letter X are displayed in uppercase.”
e/E	Scientific notation	“Displays a floating-point number in scientific notation. When “E” is specified, the letter “E” in the notation will be uppercase. The “#” flag mandates a decimal point even if there are no decimal digits.”
f	Floating point number	“Represents a floating-point number. Using the “#” flag ensures that a decimal point is included, even if there are no decimal digits.”
g/G	General number	“Shows the shortest representation for a floating-point number between ‘f’ and ‘e’ or ‘E’.”
a/a	Hexadecimal floating point number	“Show the internal representation of a floating-point number using hexadecimal digits.”
t/T	Time or date	“Shows a formatted date or time. The ‘t’ or ‘T’ must be followed by one additional character indicating the desired format for the date or time. When ‘T’ is specified, text components like “JANUARY” will be displayed in uppercase.” Here are the available characters for formatting date and time: H: 24-hour format of hour (00 to 23) I: 12-hour format of hour (01 to 12) k: 24-hour format of hour (0 to 23) l (lowercase ‘L’): 12-hour format of hour (1 to 12) M: Minutes with leading zeros (00 to 59) S: Seconds with leading zeros (00 to 59) (may reach 60 for leap seconds) L: Milliseconds with leading zeroes (000 to 999) N: Nanoseconds with leading zeroes (000000000 to 999999999) p: “am”, “pm”, “AM”, or “PM” to indicate morning or afternoon z: Difference to Greenwich time (e.g., -0800) Z: Timezone abbreviations (e.g., EST, MDT) s: Seconds since the Unix Epoch (January 1, 1970, 00:00:00 GMT) Q: Milliseconds since the Unix Epoch (January 1, 1970, 00:00:00 GMT) B: Full textual representation of a month (e.g., January through December) b or h: Short textual representation of a month (three letters) A: Full textual representation of a day (e.g., Monday) a: Short textual representation of a day (e.g., Mon) C: First two digits of the year (e.g., for 1970, “19” would be shown) Y: Four-digit representation of a year y: Two-digit representation of a year j: Day of the year with leading zeros (001 to 366) m: Numeric representation of a month (01 to 12) d: Day of the month (01 to 31) e: Day of the month without leading zeros (1 to 31) R: Time in 24-hour format (e.g., 21:30) T: Time in 24-hour format with seconds (e.g., 21:30:02) r: Time in 12-hour format with seconds (e.g., 09:30:02 PM) (“AM” and “PM” are always uppercase) D: Date representation as month/day/year (e.g., 12/17/23) F: Date representation as year-month-day (e.g., 2023-12-17) c: Full date and time (e.g., Thu Mar 28 10:51:00 EDT 2024)

Syntax

“Choose one from the following options:”

public static String format(Locale locale, String format, Object... args)

public static String format(String format, Object... args)

Parameter Values

Parameter	Description
locale	“This parameter is optional and denotes a locale, which influences certain formatting aspects like the characters used for decimal points and grouping separators.”
format	“This parameter is mandatory. It’s a string to be returned, which may contain placeholders for additional arguments, specifying how they should be formatted.”
args	“This parameter is optional. You can include any number of additional arguments to the method, and their values will be formatted and shown in the resulting string.”

Technical Details

Returns	“A formatted String value using the specified locale, format, and arguments.”
Throws	“An IllegalFormatException is thrown if the format string contains an invalid placeholder or if a placeholder is not compatible with the data type of the argument.”
Java Version	1.5

More Examples

Example

“A placeholder incorporating all available components:”

String result = String.format("%2$,3.2f %1$s", "meters", 1260.5052);

System.out.println(result);

Here’s the breakdown of each element in the placeholder %2$,3.2f:

2$ specifies that the value of the second argument is utilized.
, denotes that digits should be grouped, typically by thousands.
3 ensures that the data representation is at least 3 characters long.
.2 specifies that there should be two digits following the decimal point.
f indicates that the data is represented as a floating-point number.

Example

Rephrase: “Utilize arguments in an alternative order:”

String result = String.format("%3$c %2$c %1$c", 'a', 'b', 'c');
System.out.println(result);

Example

“Format a floating-point number.”

double myNumber = 123456.78;
String result;

// Default
result = String.format("%f", myNumber);
System.out.println(result);

// Two decimal digits
result = String.format("%.2f", myNumber);
System.out.println(result);

// No decimal digits
result = String.format("%.0f", myNumber);
System.out.println(result);

// No decimal digits but keep the decimal point
result = String.format("%#.0f", myNumber);
System.out.println(result);

// Group digits
result = String.format("%,.2f", myNumber);
System.out.println(result);

// Scientific notation with two digits of precision
result = String.format("%.2e", myNumber);
System.out.println(result);

Example

“Format a date using a Unix timestamp.”

long date = 1711638903488L; // Unix timestamp (number of milliseconds since January 1, 1970)
String result

// Time
result = String.format("%tl:%<tM %<tp", date);
System.out.println(result);

// Month and day
result = String.format("%tB %<te", date);
System.out.println(result);

// Full date representation
result = String.format("%tc", date);
System.out.println(result);

Example

“Display characters based on their Unicode code points.”

String result;

// Represent characters from their unicode code points
result = String.format("%c%c%c%c%c", 72, 101, 108, 108, 111);
System.out.println(result);

// Force unicode characters to uppercase
result = String.format("%C%C%C%C%C", 72, 101, 108, 108, 111);
System.out.println(result);