How to Format Dates in Java 8

Introduction

Java 8 introduced the java.time package, which offers a modern and intuitive way to handle dates and times. One of the essential tasks when working with dates is formatting them for display or storage. The DateTimeFormatter class in Java 8 provides flexible and powerful ways to format date and time objects like LocalDate, LocalTime, LocalDateTime, and ZonedDateTime. Whether you need to format a date for user interfaces, logs, or data exchange, Java 8’s DateTimeFormatter makes it easy.

In this guide, we’ll explore how to format dates in Java 8 using DateTimeFormatter. We’ll cover common formatting patterns, creating custom formats, and formatting various date-time objects.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Formatting LocalDate
  • Formatting LocalTime
  • Formatting LocalDateTime
  • Custom Date-Time Formatting
  • Formatting with Predefined Formats
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Formats date and time objects using predefined patterns.
• Allows custom formatting of dates and times.
• Applies formatting to different date-time objects, such as LocalDate, LocalTime, and LocalDateTime.

Example:

• Input: LocalDate representing 2024-08-30
• Output: Formatted date string "30-Aug-2024"

Solution Steps

1. Use DateTimeFormatter: Utilize DateTimeFormatter to define both predefined and custom date-time formats.
2. Apply Formatting: Use the format() method of date-time objects to apply the formatting.
3. Handle Various Date-Time Objects: Format different types of date-time objects, including LocalDate, LocalTime, and LocalDateTime.

Java Program

Formatting LocalDate

To format a LocalDate object, use a DateTimeFormatter with a specific pattern.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

/**
 * Java 8 - Formatting LocalDate
 * Author: https://www.rameshfadatare.com/
 */
public class FormatLocalDate {

    public static void main(String[] args) {
        // Step 1: Get the current date
        LocalDate currentDate = LocalDate.now();

        // Step 2: Define a formatter with a specific pattern
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MMM-yyyy");

        // Step 3: Format the LocalDate using the formatter
        String formattedDate = currentDate.format(formatter);

        // Step 4: Display the formatted date
        System.out.println("Formatted LocalDate: " + formattedDate);
    }
}

Output

Formatted LocalDate: 30-Aug-2024

Explanation

• The DateTimeFormatter.ofPattern("dd-MMM-yyyy") creates a formatter for the pattern dd-MMM-yyyy.
• The currentDate.format(formatter) method formats the LocalDate object according to the specified pattern.

Formatting LocalTime

Similarly, you can format a LocalTime object.

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

/**
 * Java 8 - Formatting LocalTime
 * Author: https://www.rameshfadatare.com/
 */
public class FormatLocalTime {

    public static void main(String[] args) {
        // Step 1: Get the current time
        LocalTime currentTime = LocalTime.now();

        // Step 2: Define a formatter with a specific pattern
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");

        // Step 3: Format the LocalTime using the formatter
        String formattedTime = currentTime.format(formatter);

        // Step 4: Display the formatted time
        System.out.println("Formatted LocalTime: " + formattedTime);
    }
}

Output

Formatted LocalTime: 14:45:30

Explanation

• The DateTimeFormatter.ofPattern("HH:mm:ss") creates a formatter for the pattern HH:mm:ss.
• The currentTime.format(formatter) method formats the LocalTime object according to the specified pattern.

Formatting LocalDateTime

You can format a LocalDateTime object to include both date and time.

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * Java 8 - Formatting LocalDateTime
 * Author: https://www.rameshfadatare.com/
 */
public class FormatLocalDateTime {

    public static void main(String[] args) {
        // Step 1: Get the current date and time
        LocalDateTime currentDateTime = LocalDateTime.now();

        // Step 2: Define a formatter with a specific pattern
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MMM-yyyy HH:mm:ss");

        // Step 3: Format the LocalDateTime using the formatter
        String formattedDateTime = currentDateTime.format(formatter);

        // Step 4: Display the formatted date and time
        System.out.println("Formatted LocalDateTime: " + formattedDateTime);
    }
}

Output

Formatted LocalDateTime: 30-Aug-2024 14:45:30

Explanation

• The DateTimeFormatter.ofPattern("dd-MMM-yyyy HH:mm:ss") creates a formatter for the pattern dd-MMM-yyyy HH:mm:ss.
• The currentDateTime.format(formatter) method formats the LocalDateTime object according to the specified pattern.

Custom Date-Time Formatting

You can define custom date-time formats using DateTimeFormatter to suit your specific needs.

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * Java 8 - Custom Date-Time Formatting
 * Author: https://www.rameshfadatare.com/
 */
public class CustomDateTimeFormatting {

    public static void main(String[] args) {
        // Step 1: Get the current date and time
        LocalDateTime currentDateTime = LocalDateTime.now();

        // Step 2: Define a custom formatter
        DateTimeFormatter customFormatter = DateTimeFormatter.ofPattern("EEEE, MMMM dd, yyyy HH:mm:ss");

        // Step 3: Format the LocalDateTime using the custom formatter
        String formattedDateTime = currentDateTime.format(customFormatter);

        // Step 4: Display the formatted date and time
        System.out.println("Custom Formatted DateTime: " + formattedDateTime);
    }
}

Output

Custom Formatted DateTime: Friday, August 30, 2024 14:45:30

Explanation

• The DateTimeFormatter.ofPattern("EEEE, MMMM dd, yyyy HH:mm:ss") creates a formatter for a custom pattern that includes the day of the week and full month name.
• The currentDateTime.format(customFormatter) method formats the LocalDateTime object according to the custom pattern.

Formatting with Predefined Formats

Java 8 provides several predefined formats, such as ISO_DATE, ISO_TIME, and ISO_DATE_TIME.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

/**
 * Java 8 - Formatting with Predefined Formats
 * Author: https://www.rameshfadatare.com/
 */
public class PredefinedDateTimeFormatting {

    public static void main(String[] args) {
        // Step 1: Get the current date
        LocalDate currentDate = LocalDate.now();

        // Step 2: Format the date using ISO_DATE
        String isoFormattedDate = currentDate.format(DateTimeFormatter.ISO_DATE);

        // Step 3: Display the formatted date
        System.out.println("ISO Formatted Date: " + isoFormattedDate);
    }
}

Output

ISO Formatted Date: 2024-08-30

Explanation

• The DateTimeFormatter.ISO_DATE is a predefined formatter that follows the ISO-8601 standard for date formatting.
• The currentDate.format(DateTimeFormatter.ISO_DATE) method formats the LocalDate object using this predefined format.

Advanced Considerations

• Locale-Specific Formatting: If you need to format dates and times according to specific locales, consider using DateTimeFormatter with locale settings.

• Handling Time Zones: For date-time objects that include time zones, such as ZonedDateTime, ensure that your formatter includes the appropriate zone information.

• Immutable and Thread-Safe: The DateTimeFormatter class, like other classes in the java.time package, is immutable and thread-safe, making it suitable for use in concurrent applications.

Conclusion

This guide provides methods for formatting dates in Java 8 using DateTimeFormatter, covering scenarios such as formatting LocalDate, LocalTime, LocalDateTime, custom formatting, and using predefined formats. The new date and time API in Java 8 offers a flexible and powerful way to handle date formatting, making your code more readable, maintainable, and adaptable to different formatting requirements. By understanding how to use DateTimeFormatter effectively, you can create robust Java applications that handle date and time formatting with ease.