java.time.format.DateTimeFormatterBuilder Class in Java

The DateTimeFormatterBuilder class in the java.time.format package is a builder class used to create custom DateTimeFormatter objects. It provides a flexible way to define complex date-time formatting and parsing rules by combining multiple formatting elements.

Allows combining multiple formatting elements into a single formatter.
Supports optional sections for flexible parsing.
Enables adding custom literals, date-time fields, and patterns.

Syntax

public final class DateTimeFormatterBuilder
extends Object

Constructor of DateTimeFormatterBuilder

DateTimeFormatterBuilder()

Creates an empty DateTimeFormatterBuilder that can be configured using builder methods.

Approach

Import the required classes from the java.time and java.time.format packages.
Create a DateTimeFormatterBuilder object.
Append the required date/time fields, patterns, or literals.
Convert the builder into a DateTimeFormatter using toFormatter().
Format or parse date-time values using the formatter.

Example: Program to Illustrate DateTimeFormatterBuilder class by invoking appendValue() Method of this class

Java

// Importing required classes from respective packages
import java.io.*;
import java.lang.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.TextStyle;
import java.time.temporal.ChronoField;

// Main class
public class GFG {

    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of this class
        // inside main() method
        DateTimeFormatterBuilder builder
            = new DateTimeFormatterBuilder();

        // Now creating object of DateTimeFormatter class
        // over which appendValue() method is invoked
        DateTimeFormatter formatter
            = builder.appendLiteral("Day is:")
                  .appendValue(ChronoField.DAY_OF_MONTH)
                  .appendLiteral(", Month is:")
                  .appendValue(ChronoField.MONTH_OF_YEAR)
                  .toFormatter();

        // Creating object of LocalDateTime class
        // invoking now() method over it
        LocalDateTime dateTime = LocalDateTime.now();

        // Formatting the date and lately
        // storing it in a string
        String str = dateTime.format(formatter);

        // Print and display the day and month
        System.out.println(str);
    }
}

Output

Day is:2, Month is:2

Explanation: This example creates a custom formatter using appendLiteral() and appendValue(). It formats the current date by displaying the day and month with custom labels.

Example: Using optionalStart() and optionalEnd() Methods

Java

// Importing required libraries
import java.io.*;
import java.lang.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.ChronoField;

// Main class
public class GFG {

    // Main driver methods
    public static void main(String[] args)
    {

        // Creating an object of DateTimeFormatter class
        DateTimeFormatter parser
            = new DateTimeFormatterBuilder()
                  .appendPattern("[yyyy][yyyyMM][yyyyMMdd]")
                  .optionalStart()
                  .parseDefaulting(
                      ChronoField.MONTH_OF_YEAR, 1)
                  .parseDefaulting(ChronoField.DAY_OF_MONTH,
                                   1)
                  .optionalEnd()
                  .toFormatter();

        // Print and display statements

        // Execute if only year is given in parameter
        System.out.println(
            parser.parse("2021", LocalDate::from));

        // Execute if year and month is given
        System.out.println(
            parser.parse("202106", LocalDate::from));

        // Execute if year, month and date is given
        System.out.println(
            parser.parse("20210631", LocalDate::from));
    }
}

Output

2021-01-01
2021-06-01
2021-06-30

Explanation: This example demonstrates optional parsing sections. The formatter accepts input in multiple formats (yyyy, yyyyMM, and yyyyMMdd). Missing month and day values are automatically assigned default values using parseDefaulting().

Example 3: Java Program to illustrate DateTimeFormatterBuilder Class

Java

// Importing required classes
import java.io.*;
import java.lang.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.TextStyle;
import java.time.temporal.ChronoField;
import java.util.Locale;

// Main class
// DateTimeFormatterBuilderExample
class GFG {

    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of LocalDate class
        // inside main() method
        LocalDate date = LocalDate.of(2021, 6, 30);

        // Creating object of DateTimeFormatter class

        // Object 1
        DateTimeFormatter formatter
            = DateTimeFormatter.ofPattern("dd/MM/yyyy");

        // Object 2
        DateTimeFormatter italianFormatter
            = DateTimeFormatter.ofPattern("d. MMMM yyyy",
                                          Locale.ITALIAN);

        // Print and display date in format XX-XX-XX
        System.out.println(
            date.format(DateTimeFormatter.ISO_LOCAL_DATE));

        // Print and display date in format XX/XX/XX
        System.out.println(date.format(formatter));

        // Print and display Italian date formatter
        System.out.println(date.format(italianFormatter));

        // Object 3
        DateTimeFormatter complexFormatter
            = new DateTimeFormatterBuilder()
                  .appendText(ChronoField.DAY_OF_MONTH)
                  .appendLiteral(". ")
                  .appendText(ChronoField.MONTH_OF_YEAR)
                  .appendLiteral(" ")
                  .appendText(ChronoField.YEAR)
                  .parseCaseInsensitive()
                  .toFormatter(Locale.US);

        // Print and display US date formatter
        System.out.println(date.format(complexFormatter));
    }
}

Output

2021-06-30
30/06/2021
30. giugno 2021
30. June 2021

Explanation: This example demonstrates different ways to format a date. It uses predefined patterns, locale-specific formatting, and a custom formatter built using DateTimeFormatterBuilder to display the date in different formats.

Common Methods of DateTimeFormatterBuilder

They are pictorially depicted below in tabular format in alphabetical alongside the action performed by them which are as follows:

Method	Description
`append(DateTimeFormatter formatter)`	Appends the elements of another formatter to the builder.
`appendPattern(String pattern)`	Appends date-time elements defined by a pattern.
`appendLiteral(char literal)`	Appends a character literal to the formatter.
`appendLiteral(String literal)`	Appends a string literal to the formatter.
`appendValue(TemporalField field)`	Appends the numeric value of the specified date-time field.
`appendText(TemporalField field)`	Appends the textual representation of a date-time field.
`appendFraction(TemporalField field, int minWidth, int maxWidth, boolean decimalPoint)`	Appends the fractional value of a date-time field.
`appendOptional(DateTimeFormatter formatter)`	Appends another formatter as an optional section.
`optionalStart()`	Marks the beginning of an optional section.
`optionalEnd()`	Marks the end of an optional section.
`parseCaseInsensitive()`	Makes subsequent parsing case-insensitive.
`parseCaseSensitive()`	Makes subsequent parsing case-sensitive.
`parseDefaulting(TemporalField field, long value)`	Provides a default value for a field when it is absent during parsing.
`toFormatter()`	Creates a `DateTimeFormatter` from the builder using the default locale.
`toFormatter(Locale locale)`	Creates a `DateTimeFormatter` using the specified locale.

Advantages of DateTimeFormatterBuilder

Complex Formatting: Builds formatters that go beyond simple pattern-based formatting.
Flexible Parsing: Supports optional sections and default values for handling different input formats.
Custom Formatting Rules: Allows literals, fields, text styles, and other formatting components to be combined as required.
Reusable Formatters: The resulting DateTimeFormatter objects can be reused for formatting and parsing.

java.time.format.DateTimeFormatterBuilder Class in Java

Syntax

Constructor of DateTimeFormatterBuilder

Approach

Common Methods of DateTimeFormatterBuilder

Advantages of DateTimeFormatterBuilder

Explore