How do I format a date using DateTimeFormatter in Java?

Use DateTimeFormatter to turn a LocalDate into text. You can choose the order of the day, month, and year, and use a locale to control the language of the month name.

In this example, you will format the same date in two ways: 11/11/2026 and 11 November 2026.

Source code

Save the following code as DateFormattingExample.java:

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

public class DateFormattingExample {
    void main() {
        LocalDate date = LocalDate.of(2026, 11, 11);

        DateTimeFormatter numericFormat =
                DateTimeFormatter.ofPattern("dd/MM/uuuu");
        DateTimeFormatter longFormat =
                DateTimeFormatter.ofPattern("d MMMM uuuu", Locale.ENGLISH);

        IO.println("Numeric date: " + date.format(numericFormat));
        IO.println("Date with month name: " + date.format(longFormat));
    }
}

Explanation

LocalDate.of(2026, 11, 11) creates a date using the year, month, and day in that order. A LocalDate stores a calendar date without a time or time zone.

The ofPattern() method creates a formatter from a pattern. The letters are case-sensitive:

Pattern Meaning Example
d Day of the month without zero padding 5
dd Day of the month padded to two digits 05
MM Month number padded to two digits 03
MMMM Full month name March
uuuu Calendar year, padded to at least four digits 2026

Slashes and spaces in these patterns appear as written. Locale.ENGLISH makes the full month name appear in English regardless of the system’s default locale.

The date.format(...) call returns a string. You can format the same date in multiple ways because formatting leaves the LocalDate unchanged.

Use uuuu for the calendar year in these patterns. Uppercase YYYY means the week-based year, which can differ from the calendar year near the start or end of a year.

Run the example

Compile and run the file:

javac DateFormattingExample.java
java DateFormattingExample

Output

Numeric date: 11/11/2026
Date with month name: 11 November 2026

To see the difference between d and dd, change the date to LocalDate.of(2026, 3, 5). The numeric format displays 05/03/2026, and the format with the month name displays 5 March 2026.

How to Create a Custom Date Comparator in Java

To create a custom date comparator in Java, you can follow these steps:

1. Understand the Requirements

A date comparator is used to sort objects based on date values. For instance, consider a User class that has a Date field (e.g., ). We’ll compare and sort User instances by that date. birthDate

2. Define a Custom Comparator

In Java, you can create a Comparator by implementing the compare method or using lambda expressions along with the Comparator utility.

Example Code for Custom Date Comparator:

Here’s an example of creating a custom date comparator for sorting objects by date:

import java.util.*;
import java.util.stream.Stream;
import java.text.SimpleDateFormat;

public class CustomDateComparatorExample {

    public static void main(String[] args) throws Exception {

        // Sample date format and users with dates
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Stream<User> usersStream = Stream.of(
                new User("John", dateFormat.parse("1993-05-12")),
                new User("Rose", dateFormat.parse("1994-11-28")),
                new User("Adam", dateFormat.parse("1987-07-15"))
        );

        // Custom Date Comparator using Comparator.comparing
        usersStream
                .sorted(Comparator.comparing(User::getBirthDate))
                .forEach(System.out::println);
    }

    static class User {
        String name;
        Date birthDate;

        User(String name, Date birthDate) {
            this.name = name;
            this.birthDate = birthDate;
        }

        String getName() {
            return name;
        }

        Date getBirthDate() {
            return birthDate;
        }

        @Override
        public String toString() {
            return "User{" + "name='" + name + '\'' +
                    ", birthDate=" + birthDate + '}';
        }
    }
}

Explanation:

  1. Date Field ()birthDate:
    • Replaced age with a Date field () in the User class to sort based on dates. birthDate
  2. Custom Comparator:
    • Used Comparator.comparing() to directly compare the field. birthDate
    • It simplifies creating a comparator for a specific field, which in this case is a Date object.
  3. Sorted Stream:
    • The Stream.sorted() function is applied with our custom comparator. It ensures the stream of User objects is sorted.

Alternative: Manually Implement the Comparator

You can define the comparator manually for more control:

// Custom Comparator Implementation
Comparator<User> dateComparator = new Comparator<User>() {
    @Override
    public int compare(User u1, User u2) {
        return u1.getBirthDate().compareTo(u2.getBirthDate());
    }
};

// Usage
usersStream.sorted(dateComparator).forEach(System.out::println);

This is especially useful if you need more complex comparison logic (e.g., null handling or multi-level comparison).

Points to Remember:

  • Null Safety: Always handle null dates to avoid. Use Comparator.nullsFirst() or Comparator.nullsLast() when necessary. NullPointerException
    Comparator.comparing(User::getBirthDate, Comparator.nullsFirst(Date::compareTo));
    
  • Custom Date Format: Adjust the date format as needed using SimpleDateFormat, LocalDate, or other relevant classes from java.time.
    With this knowledge, you can tailor the comparator to fit any specific user-defined date or object sorting needs!

How to Check If a Date Is Weekend in Java

Here are simple and reliable ways to check whether a date falls on a weekend in Java. Prefer the modern java.time API (Java 8+), which is clearer and thread-safe.

  • Using LocalDate (recommended)
import java.time.DayOfWeek;
import java.time.LocalDate;

public class WeekendChecker {
    public static boolean isWeekend(LocalDate date) {
        DayOfWeek dow = date.getDayOfWeek();
        return dow == DayOfWeek.SATURDAY || dow == DayOfWeek.SUNDAY;
    }

    public static void main(String[] args) {
        System.out.println(isWeekend(LocalDate.now())); // true or false
    }
}
  • With time zones (e.g., when you start from an Instant)
import java.time.*;

public class WeekendCheckerTZ {
    public static boolean isWeekend(Instant instant, ZoneId zone) {
        DayOfWeek dow = instant.atZone(zone).getDayOfWeek();
        return dow == DayOfWeek.SATURDAY || dow == DayOfWeek.SUNDAY;
    }

    public static void main(String[] args) {
        boolean weekendInNY = isWeekend(Instant.now(), ZoneId.of("America/New_York"));
        System.out.println(weekendInNY);
    }
}
  • If you still use the legacy Calendar API
import java.util.Calendar;

public class WeekendCheckerLegacy {
    public static boolean isWeekend(Calendar cal) {
        int dow = cal.get(Calendar.DAY_OF_WEEK);
        return dow == Calendar.SATURDAY || dow == Calendar.SUNDAY;
    }
}
  • Configurable “weekend” definition (some regions consider Friday/Saturday)
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.util.EnumSet;
import java.util.Set;

public class ConfigurableWeekend {
    private static final Set<DayOfWeek> DEFAULT_WEEKEND = EnumSet.of(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY);

    public static boolean isWeekend(LocalDate date, Set<DayOfWeek> weekendDays) {
        return weekendDays.contains(date.getDayOfWeek());
    }

    public static void main(String[] args) {
        System.out.println(isWeekend(LocalDate.now(), DEFAULT_WEEKEND));
        // Example for Fri/Sat weekend:
        Set<DayOfWeek> friSatWeekend = EnumSet.of(DayOfWeek.FRIDAY, DayOfWeek.SATURDAY);
        System.out.println(isWeekend(LocalDate.now(), friSatWeekend));
    }
}

Notes:

  • Use java.time classes (LocalDate, ZonedDateTime, DayOfWeek) for new code.
  • If you have a timestamp without a zone (Instant), convert with a ZoneId before checking the day of the week.

How to Convert Between Date and LocalDateTime

In Java, you can convert between java.util.Date and java.time.LocalDateTime using the java.time API introduced in Java 8. Here’s how you can perform the conversions:


1. Converting Date to LocalDateTime

You need to use java.time.Instant and java.time.ZoneId to make this conversion. Here’s the process:

package org.kodejava.datetime;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class DateToLocalDateTimeExample {
    public static void main(String[] args) {
        // Create a Date object
        Date date = new Date();

        // Convert Date to LocalDateTime
        LocalDateTime localDateTime = date.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDateTime();

        System.out.println("Date: " + date);
        System.out.println("LocalDateTime: " + localDateTime);
    }
}

2. Converting LocalDateTime to Date

To convert back from LocalDateTime to Date, again you will make use of Instant and ZoneId.

package org.kodejava.datetime;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class LocalDateTimeToDateExample {
    public static void main(String[] args) {
        // Create a LocalDateTime object
        LocalDateTime localDateTime = LocalDateTime.now();

        // Convert LocalDateTime to Date
        Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());

        System.out.println("LocalDateTime: " + localDateTime);
        System.out.println("Date: " + date);
    }
}

Explanation:

  1. Date to LocalDateTime:
    • Date.toInstant() converts the Date object into an Instant (a specific point in time).
    • .atZone(ZoneId.systemDefault()) adjusts the instant to your system’s default time zone.
    • .toLocalDateTime() converts the zoned date-time to a LocalDateTime.
  2. LocalDateTime to Date:
    • .atZone(ZoneId.systemDefault()) converts a LocalDateTime into a ZonedDateTime.
    • ZonedDateTime.toInstant() gets an Instant for the given date and time in the local zone.
    • Date.from(Instant) creates a Date object from the Instant.

By using these conversions, you can easily switch between the old java.util.Date and the modern java.time.LocalDateTime API.

How to Calculate Date Differences Using ChronoUnit

You can calculate date differences in Java using the ChronoUnit enum from the java.time package. The ChronoUnit class is used to measure the amount of time between two temporal objects (e.g., LocalDate, LocalDateTime, etc.) in terms of specific time units like DAYS, MONTHS, YEARS, etc.

Here’s an example of how to calculate the difference between two LocalDate objects in various time units:

Example Code

package org.kodejava.datetime;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class DateDifferenceExample {
    public static void main(String[] args) {
        // Define two dates
        LocalDate date1 = LocalDate.of(2023, 1, 1);
        LocalDate date2 = LocalDate.of(2025, 8, 7);

        // Calculate differences using ChronoUnit
        long daysBetween = ChronoUnit.DAYS.between(date1, date2);
        long monthsBetween = ChronoUnit.MONTHS.between(date1, date2);
        long yearsBetween = ChronoUnit.YEARS.between(date1, date2);

        // Print results
        System.out.println("Days between: " + daysBetween);
        System.out.println("Months between: " + monthsBetween);
        System.out.println("Years between: " + yearsBetween);
    }
}

Output

Days between: 949
Months between: 31
Years between: 2

Explanation

  1. between() Method:
    • The ChronoUnit.between() method takes two temporal objects as parameters and returns the difference in the specified unit (e.g., days, months, or years).
    • Ensure that the objects provided are compatible (e.g., both are LocalDate or LocalDateTime).
  2. Units of Measurement:
    • The ChronoUnit enum provides different constants such as DAYS, HOURS, WEEKS, MONTHS, YEARS, etc., to calculate differences at the desired granularity.
  3. Signed Differences:
    • The result may be negative if the first date is later than the second date. You can swap the dates if you want an absolute difference.

Other Temporal Types

ChronoUnit also works with other temporal types such as LocalDateTime, ZonedDateTime, Instant, etc. For example:

package org.kodejava.datetime;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class LocalDateTimeDifference {
    public static void main(String[] args) {
        LocalDateTime dateTime1 = LocalDateTime.of(2023, 1, 1, 10, 0);
        LocalDateTime dateTime2 = LocalDateTime.of(2025, 8, 7, 12, 30);

        long hoursBetween = ChronoUnit.HOURS.between(dateTime1, dateTime2);
        long minutesBetween = ChronoUnit.MINUTES.between(dateTime1, dateTime2);

        System.out.println("Hours between: " + hoursBetween);
        System.out.println("Minutes between: " + minutesBetween);
    }
}

This will give you the time differences in hours and minutes.

Note

  • ChronoUnit.WEEKS may not align perfectly with ChronoUnit.DAYS due to week boundaries.
  • Always validate whether the specific ChronoUnit applies to the temporal objects you’re comparing (e.g., you can’t use HOURS on LocalDate because it lacks time information).