Java ZonedDateTime class

by

Java’s ZonedDateTime class is part of the java.time package and represents a date and time with a time zone. It includes information about the time zone offset from UTC (Coordinated Universal Time) and any daylight saving time rules that apply.

Here’s an example of how to create a ZonedDateTime object:

// Create a ZonedDateTime object representing the current date and time in the default time zone
ZonedDateTime zonedDateTime = ZonedDateTime.now();

// Create a ZonedDateTime object for a specific date and time in a specific time zone
ZonedDateTime zonedDateTime2 = ZonedDateTime.of(2023, 4, 27, 14, 30, 0, 0, ZoneId.of("America/Los_Angeles"));

You can perform various operations on ZonedDateTime objects, such as getting the date or time, adding or subtracting time, or converting to a different time zone. Here are some examples:

// Get the date and time components of a ZonedDateTime
LocalDate date = zonedDateTime.toLocalDate();
LocalTime time = zonedDateTime.toLocalTime();

// Add or subtract time from a ZonedDateTime
ZonedDateTime newDateTime = zonedDateTime.plusHours(2);
ZonedDateTime newDateTime2 = zonedDateTime.minusDays(1);

// Convert a ZonedDateTime to a different time zone
ZonedDateTime convertedDateTime = zonedDateTime.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));

The ZonedDateTime class is useful when dealing with date and time information that needs to be associated with a specific time zone.

Java ZonedDateTime class declaration:

Here’s the declaration of the ZonedDateTime class in Java:

public final class ZonedDateTime
    extends Object
    implements Temporal, TemporalAdjuster, ChronoZonedDateTime<LocalDate>

The ZonedDateTime class is a final class, which means it cannot be subclassed. It extends the Object class and implements several interfaces, including Temporal, TemporalAdjuster, and ChronoZonedDateTime<LocalDate>.

As mentioned earlier, the ZonedDateTime class represents a date and time with a time zone, and includes information about the time zone offset from UTC and any daylight saving time rules that apply. It provides a wide range of methods to manipulate and work with date and time information.

Methods of Java ZonedDateTime:

The ZonedDateTime class in Java provides a wide range of methods to manipulate and work with date and time information. Here are some of the commonly used methods:

Creation and Conversion Methods

  • now(): Returns the current date and time in the default time zone.
  • of(year, month, dayOfMonth, hour, minute, second, nanoOfSecond, zone): Creates a ZonedDateTime object with the given year, month, day of the month, hour, minute, second, nanosecond, and time zone.
  • parse(text): Parses a string representation of a date and time in ISO-8601 format and returns a ZonedDateTime object.

Getters

  • getYear(): Returns the year of the date.
  • getMonth(): Returns the month of the date.
  • getDayOfMonth(): Returns the day of the month of the date.
  • getDayOfWeek(): Returns the day of the week of the date.
  • getHour(): Returns the hour of the time.
  • getMinute(): Returns the minute of the time.
  • getSecond(): Returns the second of the time.
  • getNano(): Returns the nanosecond of the time.
  • getZone(): Returns the time zone of the date and time.

Setters

  • withYear(year): Returns a copy of the ZonedDateTime with the year set to the specified value.
  • withMonth(month): Returns a copy of the ZonedDateTime with the month set to the specified value.
  • withDayOfMonth(dayOfMonth): Returns a copy of the ZonedDateTime with the day of the month set to the specified value.
  • withHour(hour): Returns a copy of the ZonedDateTime with the hour of the time set to the specified value.
  • withMinute(minute): Returns a copy of the ZonedDateTime with the minute of the time set to the specified value.
  • withSecond(second): Returns a copy of the ZonedDateTime with the second of the time set to the specified value.
  • withNano(nanoOfSecond): Returns a copy of the ZonedDateTime with the nanosecond of the time set to the specified value.
  • withZoneSameInstant(zone): Returns a copy of the ZonedDateTime with the time zone set to the specified value, adjusting the date and time if necessary to maintain the same instant in time.

Arithmetic Methods

  • plusYears(years): Returns a copy of the ZonedDateTime with the specified number of years added.
  • plusMonths(months): Returns a copy of the ZonedDateTime with the specified number of months added.
  • plusWeeks(weeks): Returns a copy of the ZonedDateTime with the specified number of weeks added.
  • plusDays(days): Returns a copy of the ZonedDateTime with the specified number of days added.
  • plusHours(hours): Returns a copy of the ZonedDateTime with the specified number of hours added.
  • plusMinutes(minutes): Returns a copy of the ZonedDateTime with the specified number of minutes added.
  • plusSeconds(seconds): Returns a copy of the ZonedDateTime with the specified number of seconds added.
  • plusNanos(nanos): Returns a copy of the ZonedDateTime with the specified number of nanoseconds added.
  • minusYears(years): Returns a copy of the ZonedDateTime with the specified number of years subtracted.
  • minusMonths(months): Returns a copy of the ZonedDateTime

Java ZonedDateTime class Example:

Sure, here’s an example that demonstrates how to use the ZonedDateTime class in Java:

import java.time.*;

public class ZonedDateTimeExample {
    public static void main(String[] args) {
        // Create a ZonedDateTime object for the current date and time
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println("Current date and time: " + now);

        // Create a ZonedDateTime object for a specific date and time
        ZonedDateTime dateTime = ZonedDateTime.of(
                2022, 10, 31, 12, 0, 0, 0, ZoneId.of("America/New_York"));
        System.out.println("Halloween 2022 in New York: " + dateTime);

        // Get the year, month, and day of the ZonedDateTime object
        int year = now.getYear();
        Month month = now.getMonth();
        int day = now.getDayOfMonth();
        System.out.printf("Year: %d, Month: %s, Day: %d%n", year, month, day);

        // Add 3 days to the ZonedDateTime object
        ZonedDateTime threeDaysLater = now.plusDays(3);
        System.out.println("Three days later: " + threeDaysLater);

        // Subtract 2 hours from the ZonedDateTime object
        ZonedDateTime twoHoursEarlier = now.minusHours(2);
        System.out.println("Two hours earlier: " + twoHoursEarlier);
    }
}

In this example, we first create a ZonedDateTime object for the current date and time using the now() method. We then create another ZonedDateTime object for a specific date and time using the of() method. We specify the year, month, day of the month, hour, minute, second, nanosecond, and time zone when creating the object.

We then use the getYear(), getMonth(), and getDayOfMonth() methods to get the year, month, and day of the ZonedDateTime object, respectively. We print these values using System.out.printf().

Next, we use the plusDays() method to add three days to the ZonedDateTime object and the minusHours() method to subtract two hours from it. Finally, we print the resulting ZonedDateTime objects using System.out.println().

Java ZonedDateTime class Example: of() and withZoneSameInstant():

Sure, here’s another example that demonstrates the usage of of() and withZoneSameInstant() methods of ZonedDateTime class:

import java.time.*;

public class ZonedDateTimeExample2 {
    public static void main(String[] args) {
        // Create a ZonedDateTime object for a specific date and time
        LocalDateTime localDateTime = LocalDateTime.of(2023, Month.JULY, 4, 12, 0, 0);
        ZoneId zone = ZoneId.of("America/New_York");
        ZonedDateTime dateTime = ZonedDateTime.of(localDateTime, zone);
        System.out.println("Independence Day 2023 in New York: " + dateTime);

        // Convert to a different time zone
        ZoneId newZone = ZoneId.of("Asia/Tokyo");
        ZonedDateTime newDateTime = dateTime.withZoneSameInstant(newZone);
        System.out.println("Independence Day 2023 in Tokyo: " + newDateTime);
    }
}

In this example, we create a LocalDateTime object for a specific date and time representing July 4, 2023, at 12:00 PM. We then create a ZoneId object for the time zone “America/New_York” and use the of() method to create a ZonedDateTime object for the specified LocalDateTime and time zone. We print this object using System.out.println().

Next, we create another ZoneId object for the time zone “Asia/Tokyo” and use the withZoneSameInstant() method to create a new ZonedDateTime object with the same instant in the new time zone. We print this object as well.

Note that the withZoneSameInstant() method returns a new ZonedDateTime object with the same instant in a different time zone, while the withZoneSameLocal() method returns a new ZonedDateTime object with the same local date and time in a different time zone.

Java ZonedDateTime class Example: getZone()

Sure, here’s another example that demonstrates the usage of getZone() method of ZonedDateTime class:

import java.time.*;

public class ZonedDateTimeExample3 {
    public static void main(String[] args) {
        // Create a ZonedDateTime object for the current date and time
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println("Current date and time: " + now);

        // Get the time zone of the ZonedDateTime object
        ZoneId zone = now.getZone();
        System.out.println("Time zone: " + zone);

        // Get the offset from UTC for the ZonedDateTime object
        ZoneOffset offset = now.getOffset();
        System.out.println("UTC offset: " + offset);
    }
}

In this example, we first create a ZonedDateTime object for the current date and time using the now() method. We print this object using System.out.println().

We then use the getZone() method to get the ZoneId object representing the time zone of the ZonedDateTime object. We print this object as well.

Finally, we use the getOffset() method to get the ZoneOffset object representing the offset from UTC for the ZonedDateTime object. We print this object as well.

Java ZonedDateTime class Example: minus()

Sure, here’s an example that demonstrates the usage of minus() method of ZonedDateTime class:

import java.time.*;

public class ZonedDateTimeExample4 {
    public static void main(String[] args) {
        // Create a ZonedDateTime object for a specific date and time
        LocalDateTime localDateTime = LocalDateTime.of(2023, Month.JULY, 4, 12, 0, 0);
        ZoneId zone = ZoneId.of("America/New_York");
        ZonedDateTime dateTime = ZonedDateTime.of(localDateTime, zone);
        System.out.println("Independence Day 2023 in New York: " + dateTime);

        // Subtract one day from the date and time
        ZonedDateTime newDateTime = dateTime.minusDays(1);
        System.out.println("Day before Independence Day 2023 in New York: " + newDateTime);
    }
}

In this example, we first create a LocalDateTime object for a specific date and time representing July 4, 2023, at 12:00 PM. We then create a ZoneId object for the time zone “America/New_York” and use the of() method to create a ZonedDateTime object for the specified LocalDateTime and time zone. We print this object using System.out.println().

Next, we use the minusDays() method to subtract one day from the ZonedDateTime object, which gives us the ZonedDateTime object representing the day before Independence Day 2023 in New York. We print this object as well.

Note that the minus() method can be used to subtract other types of temporal units as well, such as hours, minutes, seconds, and months.

Java ZonedDateTime class Example: plus()

Sure, here’s an example that demonstrates the usage of plus() method of ZonedDateTime class:

import java.time.*;

public class ZonedDateTimeExample5 {
    public static void main(String[] args) {
        // Create a ZonedDateTime object for a specific date and time
        LocalDateTime localDateTime = LocalDateTime.of(2023, Month.JULY, 4, 12, 0, 0);
        ZoneId zone = ZoneId.of("America/New_York");
        ZonedDateTime dateTime = ZonedDateTime.of(localDateTime, zone);
        System.out.println("Independence Day 2023 in New York: " + dateTime);

        // Add two days and six hours to the date and time
        ZonedDateTime newDateTime = dateTime.plusDays(2).plusHours(6);
        System.out.println("Independence Day 2023 in New York, two days and six hours later: " + newDateTime);
    }
}

In this example, we first create a LocalDateTime object for a specific date and time representing July 4, 2023, at 12:00 PM. We then create a ZoneId object for the time zone “America/New_York” and use the of() method to create a ZonedDateTime object for the specified LocalDateTime and time zone. We print this object using System.out.println().

Next, we use the plusDays() method to add two days to the ZonedDateTime object, and then use the plusHours() method to add six hours to the result. This gives us the ZonedDateTime object representing Independence Day 2023 in New York, two days and six hours later. We print this object as well.

Note that the plus() method can be used to add other types of temporal units as well, such as minutes, seconds, and months.