INSTITUTE OF TECHNOLOGY SCHOOL OF COMPUTING

DEPARTMENT OF SOFTWARE ENGINEERING

COURSE TITLE: OBJECT ORIENTED PROGRAMMING

COURSE CODE: SEng2062
INDIVIDUAL ASSIGNMENT
NAME ID
EYERUSALEM NIGUSE 160528

1
 SUBMMITED TO:Melese.E
SUBMMISION DATE: 29/09/2017 E.C

Introduction
In modern software development, the ability to display data clearly and
professionally is as essential as the logic that processes it. Java provides
developers with robust tools to control how data is formatted and presented.
Among these tools is the java.util.Formatter class, a powerful utility that allows
formatting of strings, numbers, dates, and other data types using format
specifiers. Similar in style to C's printf function, the Formatter class enhances
the readability, precision, and localization of output. This assignment explores
the features, advantages, limitations, and practical applications of the Formatter
class through detailed explanations and code examples. Understanding how to
format output effectively is crucial in creating user-friendly and internationally
adaptable software.

2
What is Formatter in Java?
In Java, the java.util.Formatter class provides a way to format data (numbers,
dates, strings, etc.) into a specific, readable, and localized format. It's similar in
concept to the printf function found in languages like C. It allows you to control
the appearance of your output using format strings and arguments.

Key Concepts:
Format Strings: These strings contain text and format specifiers that tell
the Formatter how to format the corresponding arguments. For example,
%d is a format specifier for integers, %f for floating-point numbers, and
%s for strings.
Arguments: The data you want to format. The arguments are matched
with the format specifiers in the format string.
Destination: The Formatter can write its output to various destinations,
such as:
 System.out (the console)
 A StringBuilder
 A File
 Any OutputStream

Advantages of Formatter:
Precise Control over Output: You have fine-grained control over the
format of your data. You can specify:
 Field width (how many characters the output should occupy)
 Precision (number of decimal places for floating-point numbers)
 Alignment (left-justified, right-justified, centered)
 Locale-specific formatting (e.g., using commas vs. periods for decimal
points, date formats)
Readability: Format strings often make the intent of the code clearer
compared to string concatenation, especially for complex output.
Locale Awareness: The Formatter class can be configured to use a
specific Locale, allowing you to format numbers, dates, and currencies

3
 according to the conventions of a particular country or region. This is
crucial for internationalization.
Flexibility: You can easily change the format of your output without
modifying the underlying data.
Centralized Formatting: You can create reusable format strings that can
be used in multiple parts of your application.
Type Safety (Somewhat): While not perfect, the Formatter will throw an
exception if you pass an argument of the wrong type for a format
specifier (e.g., trying to format a string as an integer).

Disadvantages of Formatter:
Complexity: Format strings can be complex and difficult to read or write,
especially for complicated formats. The syntax can take time to learn.
Potential for Errors: If the format string and the arguments don't match
up correctly (e.g., too few arguments, wrong types), you'll get
IllegalFormatException or its subclasses at runtime (not compile time).
This can be a source of bugs.
Performance: For very simple string formatting, string concatenation or
String.format might be slightly faster. The Formatter class has some
overhead associated with parsing the format string and handling different
data types. However, the performance difference is often negligible for
most applications.
Immutability Concerns: The Formatter itself is stateful (it maintains a
destination). Therefore, it's generally recommended to create a new
Formatter instance for each formatting operation or to ensure that you're
not sharing a Formatter across multiple threads without proper
synchronization.
Example Code:

import java.util.Formatter;

import java.util.Locale;

public class FormatterExample {

public static void main(String[] args) {

// Example 1: Basic formatting to the console

Formatter formatter = new Formatter(System.out);

String name = "Alice";

4
 int age = 30;

double salary = 50000.75;

formatter.format("Name: %s, Age: %d, Salary: %.2f\n", name, age, salary);

// Output: Name: Alice, Age: 30, Salary: 50000.75

// Example 2: Formatting to a StringBuilder

StringBuilder sb = new StringBuilder();

Formatter formatter2 = new Formatter(sb);

formatter2.format("The value of pi is approximately %.4f\n", Math.PI);

System.out.println(sb.toString());

// Output: The value of pi is approximately 3.1416

// Example 3: Locale-specific formatting

Formatter formatter3 = new Formatter(System.out, Locale.GERMANY);

double number = 1234.567;

formatter3.format("Number in Germany: %,.2f\n", number); //Comma as the decimal seperator,

period as the thousands

//Output: Number in Germany: 1.234,57

// Example 4: Field width and alignment

Formatter formatter4 = new Formatter(System.out);

formatter4.format("%10s %10s %10s\n", "Item", "Quantity", "Price");

formatter4.format("%10s %10d %10.2f\n", "Apple", 5, 0.99);

formatter4.format("%10s %10d %10.2f\n", "Banana", 12, 0.49);

// Output:

// Item Quantity Price

// Apple 5 0.99

// Banana 12 0.49

// Example 5: Using String.format

5
 String formattedString = String.format("The answer is %d", 42);

System.out.println(formattedString);

// Output: The answer is 42

//Close the formatter to flush any remaining output.

formatter.close();

formatter2.close();

formatter3.close();

formatter4.close();

Explanation of Format Specifiers:

Here's a quick rundown of common format specifiers:
 %s: String
 %d: Integer (decimal)
 %f: Floating-point number
 %c: Character
 %b: Boolean
 %t + a date/time conversion character: Date/Time
Within the % and the conversion character, you can specify additional flags and
parameters:
• Flags:
-: Left-justify the output.
0: Pad the output with zeros.
+: Include a sign (+ or -) for positive and negative numbers.
,: Use locale-specific grouping separators (e.g., commas in the US).
: Add a space before positive numbers (if no sign is present).
Width: Minimum number of characters to output. If the data is shorter, it will
be padded.
Precision: (For floating-point numbers) The number of digits after the
decimal point.

6
When to Use Formatter:
When you need precise control over the appearance of your output.
When you need to format data according to a specific locale.
When you have complex formatting requirements.
When you want to improve the readability of your code by using format
strings instead of long string concatenation chains.
When Not to Use Formatter:
For very simple string concatenation where the overhead of Formatter is
not justified. String.format is still a simpler alternative in this case.
In performance-critical sections of code where you've profiled and
determined that Formatter is a bottleneck. (But always measure first!)
String.format() as a Shortcut
 The String.format() method provides a static way to use the Formatter class
without explicitly creating a Formatter object. It's essentially a convenience
wrapper.
String formatted = String.format("Hello, %s! You are %d years old.", "Bob",
25);
System.out.println(formatted); // Output: Hello, Bob! You are 25 years old.

7
Summary
The Formatter class in Java offers developers fine-grained control over how
data is displayed. This includes options for setting field width, precision,
alignment, and even locale-specific formatting. It supports various output
destinations such as the console, files, and StringBuilder. Although it brings
many advantages such as improved readability and localization, it also has
drawbacks like complexity and potential for runtime errors if not used correctly.
Alternatives like String.format() provide simpler ways to achieve similar
results. Through examples in this assignment, the practical usage of Formatter is
demonstrated, showcasing its role in producing clean, well-structured output
that enhances software usability and professionalism.