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.
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.
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.
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.
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.
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.
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
List all Java tutorials.