Java ChronoField Enum

Last modified: April 16, 2025

The java.time.temporal.ChronoField enum implements TemporalField and represents standard fields for date and time. It provides units like year, month, day, hour, minute, and second. Each field has a range of valid values.

ChronoField is used with temporal objects like LocalDate, LocalTime, and ZonedDateTime. It enables access to specific components of date-time objects. The enum contains both date and time related fields.

ChronoField Enum Overview

ChronoField provides constants for all standard date-time fields. Each field has methods to get its range and base unit. The enum implements TemporalField interface for temporal access and adjustment.

public enum ChronoField implements TemporalField {
    NANO_OF_SECOND, NANO_OF_DAY,
    MICRO_OF_SECOND, MICRO_OF_DAY,
    MILLI_OF_SECOND, MILLI_OF_DAY,
    SECOND_OF_MINUTE, SECOND_OF_DAY,
    MINUTE_OF_HOUR, MINUTE_OF_DAY,
    HOUR_OF_AMPM, HOUR_OF_DAY,
    AMPM_OF_DAY,
    DAY_OF_WEEK, DAY_OF_MONTH, DAY_OF_YEAR,
    EPOCH_DAY,
    ALIGNED_WEEK_OF_MONTH, ALIGNED_WEEK_OF_YEAR,
    ALIGNED_DAY_OF_WEEK_IN_MONTH, ALIGNED_DAY_OF_WEEK_IN_YEAR,
    MONTH_OF_YEAR, PROLEPTIC_MONTH,
    YEAR_OF_ERA, YEAR,
    ERA,
    INSTANT_SECONDS, OFFSET_SECONDS;
    
    // Methods
    public ValueRange range();
    public boolean isDateBased();
    public boolean isTimeBased();
    public TemporalUnit getBaseUnit();
    public TemporalUnit getRangeUnit();
}

The code above shows the enum constants and key methods. Fields are categorized as date-based or time-based. Each field has a defined range of valid values accessible via range() method.

Accessing Date Components

ChronoField can extract date components like year, month, and day. Date-based fields work with temporal objects that contain date information. The example shows common date field operations.

Main.java

package com.zetcode;

import java.time.LocalDate;
import java.time.temporal.ChronoField;

public class Main {

    public static void main(String[] args) {
        
        LocalDate date = LocalDate.of(2025, 4, 15);
        
        // Get year
        int year = date.get(ChronoField.YEAR);
        System.out.println("Year: " + year);
        
        // Get month
        int month = date.get(ChronoField.MONTH_OF_YEAR);
        System.out.println("Month: " + month);
        
        // Get day of month
        int day = date.get(ChronoField.DAY_OF_MONTH);
        System.out.println("Day: " + day);
        
        // Get day of year
        int dayOfYear = date.get(ChronoField.DAY_OF_YEAR);
        System.out.println("Day of year: " + dayOfYear);
        
        // Check if field is supported
        boolean supported = date.isSupported(ChronoField.ERA);
        System.out.println("ERA supported: " + supported);
    }
}

This example demonstrates accessing date components using ChronoField. The get() method retrieves field values from temporal objects. isSupported() checks if a field is available for the temporal type.

Accessing Time Components

Time-based fields provide access to hour, minute, second, and nanosecond values. These fields work with temporal objects containing time information. The example shows common time field operations.

Main.java

package com.zetcode;

import java.time.LocalTime;
import java.time.temporal.ChronoField;

public class Main {

    public static void main(String[] args) {
        
        LocalTime time = LocalTime.of(14, 30, 45, 500_000);
        
        // Get hour
        int hour = time.get(ChronoField.HOUR_OF_DAY);
        System.out.println("Hour: " + hour);
        
        // Get minute
        int minute = time.get(ChronoField.MINUTE_OF_HOUR);
        System.out.println("Minute: " + minute);
        
        // Get second
        int second = time.get(ChronoField.SECOND_OF_MINUTE);
        System.out.println("Second: " + second);
        
        // Get nano
        int nano = time.get(ChronoField.NANO_OF_SECOND);
        System.out.println("Nanosecond: " + nano);
        
        // Check AM/PM
        int ampm = time.get(ChronoField.AMPM_OF_DAY);
        System.out.println("AMPM: " + (ampm == 0 ? "AM" : "PM"));
    }
}

This example shows how to access time components using ChronoField. The HOUR_OF_DAY provides 24-hour format while AMPM_OF_DAY distinguishes between morning and afternoon. All time fields have defined ranges.

Working with Date-Time Objects

ChronoField works with complete date-time objects like LocalDateTime and ZonedDateTime. Both date and time fields can be accessed from these objects.

Main.java

package com.zetcode;

import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;

public class Main {

    public static void main(String[] args) {
        
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println("Current date-time: " + ldt);
        
        // Get combined fields
        int year = ldt.get(ChronoField.YEAR);
        int hour = ldt.get(ChronoField.HOUR_OF_DAY);
        System.out.printf("Year: %d, Hour: %d%n", year, hour);
        
        ZonedDateTime zdt = ZonedDateTime.now();
        System.out.println("Zoned date-time: " + zdt);
        
        // Get day of week (1-7)
        int dow = zdt.get(ChronoField.DAY_OF_WEEK);
        System.out.println("Day of week: " + dow);
        
        // Get epoch day
        long epochDay = zdt.getLong(ChronoField.EPOCH_DAY);
        System.out.println("Epoch day: " + epochDay);
    }
}

This example demonstrates using ChronoField with date-time objects. Both date and time fields are accessible from the same object. Some fields like EPOCH_DAY return long values instead of integers.

Field Validation and Ranges

Each ChronoField has defined valid value ranges. These ranges can be checked before accessing fields. The range() method provides minimum and maximum values.

Main.java

package com.zetcode;

import java.time.LocalDate;
import java.time.temporal.ChronoField;
import java.time.temporal.ValueRange;

public class Main {

    public static void main(String[] args) {
        
        // Get range for day of month
        ValueRange dayRange = ChronoField.DAY_OF_MONTH.range();
        System.out.println("Day of month range: " + dayRange);
        
        // Get range for month
        ValueRange monthRange = ChronoField.MONTH_OF_YEAR.range();
        System.out.println("Month range: " + monthRange);
        
        // Check if value is valid
        LocalDate date = LocalDate.of(2025, 2, 1);
        boolean valid = date.isSupported(ChronoField.DAY_OF_MONTH) && 
                      date.range(ChronoField.DAY_OF_MONTH).isValidValue(30);
        System.out.println("Is 30 valid for February: " + valid);
        
        // Check hour range
        ValueRange hourRange = ChronoField.HOUR_OF_DAY.range();
        System.out.println("Hour range: " + hourRange);
    }
}

This example shows how to work with field ranges and validation. The range() method returns minimum and maximum valid values. isValidValue() checks if a specific value is valid for the field.

Adjusting Temporal Objects

ChronoField can be used to adjust temporal objects. The with() method creates a new object with the modified field. This is useful for date-time manipulation.

Main.java

package com.zetcode;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoField;

public class Main {

    public static void main(String[] args) {
        
        LocalDate date = LocalDate.of(2025, 4, 15);
        System.out.println("Original date: " + date);
        
        // Change year
        LocalDate newYear = date.with(ChronoField.YEAR, 2026);
        System.out.println("New year: " + newYear);
        
        // Change month
        LocalDate newMonth = date.with(ChronoField.MONTH_OF_YEAR, 12);
        System.out.println("New month: " + newMonth);
        
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println("Original date-time: " + dateTime);
        
        // Change hour
        LocalDateTime newHour = dateTime.with(ChronoField.HOUR_OF_DAY, 23);
        System.out.println("New hour: " + newHour);
        
        // Change minute
        LocalDateTime newMinute = dateTime.with(ChronoField.MINUTE_OF_HOUR, 0);
        System.out.println("New minute: " + newMinute);
    }
}

This example demonstrates adjusting temporal objects using ChronoField. The with() method returns a new object with the specified field changed. Original objects remain immutable as per Java Time API design.

Special Fields and Conversions

ChronoField includes special fields like EPOCH_DAY and INSTANT_SECONDS for conversions. These fields enable working with different time representations.

Main.java

package com.zetcode;

import java.time.Instant;
import java.time.LocalDate;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;

public class Main {

    public static void main(String[] args) {
        
        // EPOCH_DAY example
        LocalDate date = LocalDate.of(2025, 1, 1);
        long epochDay = date.getLong(ChronoField.EPOCH_DAY);
        System.out.println("Epoch day: " + epochDay);
        
        // Convert back from epoch day
        LocalDate fromEpoch = LocalDate.ofEpochDay(epochDay);
        System.out.println("From epoch day: " + fromEpoch);
        
        // INSTANT_SECONDS example
        ZonedDateTime zdt = ZonedDateTime.now();
        long instantSeconds = zdt.getLong(ChronoField.INSTANT_SECONDS);
        System.out.println("Instant seconds: " + instantSeconds);
        
        // Convert back from instant seconds
        Instant instant = Instant.ofEpochSecond(instantSeconds);
        System.out.println("From instant seconds: " + instant);
    }
}

This example shows special fields for time conversions. EPOCH_DAY represents days since 1970-01-01, while INSTANT_SECONDS represents seconds since the same epoch. These fields enable interoperability between different time representations.

Source

Java ChronoField Enum Documentation

In this article, we've covered the essential fields and features of the Java ChronoField enum. Understanding these concepts is crucial for working with date and time components 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.

Ebooks

Java ChronoField Enum

ChronoField Enum Overview

Accessing Date Components

Accessing Time Components

Working with Date-Time Objects

Field Validation and Ranges

Adjusting Temporal Objects

Special Fields and Conversions

Source

Author