Java ChronoLocalDateTime Interface

Last modified: April 16, 2025

The java.time.chrono.ChronoLocalDateTime interface represents a date-time without a time-zone in an arbitrary chronology. It is the base interface for date-time objects in different calendar systems.

ChronoLocalDateTime combines date and time components while being independent of time zones. It supports various calendar systems beyond ISO-8601. The interface is immutable and thread-safe.

ChronoLocalDateTime Overview

ChronoLocalDateTime provides methods for date-time manipulation, comparison, and formatting. It works with Chronology to support different calendar systems. The interface extends Temporal and Comparable.

public interface ChronoLocalDateTime<D extends ChronoLocalDate> extends Temporal, TemporalAdjuster, Comparable<ChronoLocalDateTime<?>> {

Chronology getChronology();
D toLocalDate();
LocalTime toLocalTime();
boolean isAfter(ChronoLocalDateTime<?> other);
boolean isBefore(ChronoLocalDateTime<?> other);
boolean isEqual(ChronoLocalDateTime<?> other);
String format(DateTimeFormatter formatter);
ChronoZonedDateTime<D> atZone(ZoneId zone);

}

The code shows key methods of ChronoLocalDateTime. These methods allow working with date-time values across different calendar systems. The interface provides precision up to nanoseconds.

Creating ChronoLocalDateTime Objects

ChronoLocalDateTime objects are typically created through implementations like JapaneseDate or HijrahDate. The ISO calendar system uses LocalDateTime.

Main.java

package com.zetcode;

import java.time.LocalDateTime; import java.time.chrono.HijrahDate; import java.time.chrono.JapaneseDate; import java.time.chrono.MinguoDate; import java.time.chrono.ThaiBuddhistDate;

public class Main {

public static void main(String[] args) {
    
    // ISO calendar system
    LocalDateTime isoDateTime = LocalDateTime.now();
    System.out.println("ISO DateTime: " + isoDateTime);
    
    // Japanese calendar system
    JapaneseDate japaneseDate = JapaneseDate.now();
    LocalDateTime japaneseTime = LocalDateTime.now();
    ChronoLocalDateTime<JapaneseDate> japaneseDateTime = 
        JapaneseDate.from(japaneseDate).atTime(japaneseTime.toLocalTime());
    System.out.println("Japanese DateTime: " + japaneseDateTime);
    
    // Hijrah calendar system
    HijrahDate hijrahDate = HijrahDate.now();
    ChronoLocalDateTime<HijrahDate> hijrahDateTime = 
        hijrahDate.atTime(LocalDateTime.now().toLocalTime());
    System.out.println("Hijrah DateTime: " + hijrahDateTime);
}

}

This example demonstrates creating ChronoLocalDateTime objects in different calendar systems. Each system combines its specific date with a standard local time. The output shows date-time values in their respective calendars.

Comparing ChronoLocalDateTime Objects

ChronoLocalDateTime supports comparison operations across different calendar systems. The comparisons are based on the same instant on the time-line.

Main.java

package com.zetcode;

import java.time.LocalDateTime; import java.time.chrono.ChronoLocalDateTime; import java.time.chrono.JapaneseDate;

public class Main {

public static void main(String[] args) {

    LocalDateTime isoDateTime = LocalDateTime.now();
    ChronoLocalDateTime<JapaneseDate> japaneseDateTime = 
        JapaneseDate.now().atTime(LocalDateTime.now().toLocalTime());
    
    System.out.println("ISO DateTime: " + isoDateTime);
    System.out.println("Japanese DateTime: " + japaneseDateTime);
    
    // Comparison
    System.out.println("Is ISO after Japanese: " + 
        isoDateTime.isAfter(japaneseDateTime));
    System.out.println("Is ISO before Japanese: " + 
        isoDateTime.isBefore(japaneseDateTime));
    System.out.println("Is ISO equal to Japanese: " + 
        isoDateTime.isEqual(japaneseDateTime));
}

}

This example compares date-time values from different calendar systems. The comparison methods convert both values to the same instant before comparing. Note that isEqual checks for the same instant, not same display.

Formatting ChronoLocalDateTime

ChronoLocalDateTime can be formatted using DateTimeFormatter. The formatter respects the chronology of the date-time value being formatted.

Main.java

package com.zetcode;

import java.time.LocalDateTime; import java.time.chrono.JapaneseDate; import java.time.chrono.ChronoLocalDateTime; import java.time.format.DateTimeFormatter;

public class Main {

public static void main(String[] args) {

    ChronoLocalDateTime<JapaneseDate> japaneseDateTime = 
        JapaneseDate.now().atTime(LocalDateTime.now().toLocalTime());
    
    // Default formatting
    System.out.println("Default format: " + japaneseDateTime);
    
    // Custom formatting
    DateTimeFormatter formatter = 
        DateTimeFormatter.ofPattern("GGGG yyyy-MM-dd HH:mm:ss");
    String formatted = japaneseDateTime.format(formatter);
    System.out.println("Custom format: " + formatted);
    
    // ISO formatting
    DateTimeFormatter isoFormatter = DateTimeFormatter.ISO_DATE_TIME;
    System.out.println("ISO format: " + japaneseDateTime.format(isoFormatter));
}

}

This example shows different ways to format ChronoLocalDateTime. The formatter includes era information for non-ISO calendars. Custom patterns can display calendar-specific fields like Japanese era names.

Converting to ZonedDateTime

ChronoLocalDateTime can be converted to ChronoZonedDateTime by adding time zone information. This conversion is essential for time zone aware operations.

Main.java

package com.zetcode;

import java.time.LocalDateTime; import java.time.ZoneId; import java.time.chrono.JapaneseDate; import java.time.chrono.ChronoLocalDateTime; import java.time.chrono.ChronoZonedDateTime;

public class Main {

public static void main(String[] args) {

    ChronoLocalDateTime<JapaneseDate> japaneseDateTime = 
        JapaneseDate.now().atTime(LocalDateTime.now().toLocalTime());
    
    // Convert to zoned date-time
    ChronoZonedDateTime<JapaneseDate> zonedDateTime = 
        japaneseDateTime.atZone(ZoneId.of("Asia/Tokyo"));
    System.out.println("Zoned Japanese DateTime: " + zonedDateTime);
    
    // Convert to another time zone
    ChronoZonedDateTime<JapaneseDate> newYorkTime = 
        zonedDateTime.withZoneSameInstant(ZoneId.of("America/New_York"));
    System.out.println("Japanese DateTime in New York: " + newYorkTime);
}

}

This example demonstrates converting between ChronoLocalDateTime and ChronoZonedDateTime. The conversion preserves the chronology while adding time zone information. Time zone conversions adjust the time accordingly.

Date and Time Manipulation

ChronoLocalDateTime supports temporal arithmetic through plus and minus methods. These operations respect the calendar system’s rules.

Main.java

package com.zetcode;

import java.time.LocalDateTime; import java.time.chrono.JapaneseDate; import java.time.chrono.ChronoLocalDateTime; import java.time.temporal.ChronoUnit;

public class Main {

public static void main(String[] args) {

    ChronoLocalDateTime<JapaneseDate> japaneseDateTime = 
        JapaneseDate.now().atTime(LocalDateTime.now().toLocalTime());
    System.out.println("Current: " + japaneseDateTime);
    
    // Add days
    ChronoLocalDateTime<JapaneseDate> nextWeek = 
        japaneseDateTime.plus(7, ChronoUnit.DAYS);
    System.out.println("Next week: " + nextWeek);
    
    // Subtract months
    ChronoLocalDateTime<JapaneseDate> lastMonth = 
        japaneseDateTime.minus(1, ChronoUnit.MONTHS);
    System.out.println("Last month: " + lastMonth);
    
    // Add hours and minutes
    ChronoLocalDateTime<JapaneseDate> later = 
        japaneseDateTime.plusHours(2).plusMinutes(30);
    System.out.println("Later today: " + later);
}

}

This example shows date-time manipulation in the Japanese calendar system. The operations handle calendar-specific rules like month lengths. All methods return new objects as ChronoLocalDateTime is immutable.

Extracting Date and Time Components

ChronoLocalDateTime provides methods to access its date and time components separately. These components maintain their calendar system characteristics.

Main.java

package com.zetcode;

import java.time.LocalDateTime; import java.time.chrono.JapaneseDate; import java.time.chrono.ChronoLocalDateTime;

public class Main {

public static void main(String[] args) {

    ChronoLocalDateTime<JapaneseDate> japaneseDateTime = 
        JapaneseDate.now().atTime(LocalDateTime.now().toLocalTime());
    
    // Get date component
    JapaneseDate date = japaneseDateTime.toLocalDate();
    System.out.println("Date: " + date);
    System.out.println("Era: " + date.getEra());
    System.out.println("Year: " + date.getYear());
    
    // Get time component
    System.out.println("Time: " + japaneseDateTime.toLocalTime());
    System.out.println("Hour: " + japaneseDateTime.getHour());
    System.out.println("Minute: " + japaneseDateTime.getMinute());
}

}

This example demonstrates accessing components of a ChronoLocalDateTime. The date component provides calendar-specific fields like era. The time component is consistent across all calendar systems.

Source

Java ChronoLocalDateTime Interface Documentation

In this article, we’ve covered the essential methods and features of the Java ChronoLocalDateTime interface. Understanding these concepts is crucial for working with multiple calendar systems in Java applications.

Author

My name is Jan Bodnar, and I am a dedicated programmer with many years of experience in the field. I began writing programming articles in 2007 and have since authored over 1,400 articles and eight e-books. With more than eight years of teaching experience, I am committed to sharing my knowledge and helping others master programming concepts.

List all Java tutorials.