How do I use java.time.Instant class of Java Date-Time API?

The java.time.Instant class in the Java Date-Time API is an immutable representation of a point in time. It stores a long count of seconds from the epoch of the first moment of 1970 UTC, plus a number of nanoseconds for the further precision within that second.

The java.time.LocalDate class represents a date without a time or time zone. It is used to represent just a date as year-month-day (e.g., 2023-03-27) in the ISO-8601 calendar system.

The java.time.LocalTime class represents a time without a date or time zone. It is used to represent just a time as hour-minute-second (e.g., 13:45:20).

It’s also worth noting that Instant class is part of Java 8’s new date and time API which was brought in to address the shortcomings of the old java.util.Date and java.util.Calendar API.

Here’s a quick example of how to use the Instant class:

package org.kodejava.datetime;

import java.time.Instant;

public class InstantExample {
    public static void main(String[] args) {
        // Get the current point in time
        Instant now = Instant.now();
        System.out.println("Current time: " + now);

        // Add duration of 500 seconds from now
        Instant later = now.plusSeconds(500);
        System.out.println("500 seconds later: " + later);

        // Subtract duration of 500 seconds from now
        Instant earlier = now.minusSeconds(500);
        System.out.println("500 seconds earlier: " + earlier);

        // Compare two Instants
        int comparison = now.compareTo(later);
        if (comparison < 0) {
            System.out.println("Now is earlier than later");
        } else if (comparison > 0) {
            System.out.println("Now is later than later");
        } else {
            System.out.println("Now and later are at the same time");
        }
    }
}

Output:

Current time: 2024-01-18T09:26:56.152268Z
500 seconds later: 2024-01-18T09:35:16.152268Z
500 seconds earlier: 2024-01-18T09:18:36.152268Z
Now is earlier than later

In this example, Instant.now() is used to get the current Instant. Various methods like plusSeconds(), minusSeconds(), and compareTo() are used to manipulate and compare the Instant.

LocalDate and LocalTime are local in the sense that they represent date and time from the context of the observer, without a time zone.

To connect Instant with LocalDate and LocalTime, you need a time zone. This is because Instant is in UTC and LocalDate/LocalTime are in a local time zone, so you need to explicitly provide a conversion between them.

Here’s how you convert an Instant to a LocalDate and a LocalTime:

package org.kodejava.datetime;

import java.time.*;

public class InstantConvertExample {
    public static void main(String[] args) {
        Instant now = Instant.now();
        System.out.println("Instant: " + now);

        // Get the system default timezone
        ZoneId zoneId = ZoneId.systemDefault(); 

        LocalDate localDate = now.atZone(zoneId).toLocalDate();
        System.out.println("LocalDate: " + localDate);

        LocalTime localTime = now.atZone(zoneId).toLocalTime();
        System.out.println("LocalTime: " + localTime);
    }
}

Here Instant.now() gives the current timestamp. .atZone(ZoneId.systemDefault()) converts it to ZonedDateTime which is then converted to LocalDate and LocalTime by using .toLocalDate() and .toLocalTime() respectively.

You can also go from LocalDate and LocalTime back to Instant. Here’s how:

package org.kodejava.datetime;

import java.time.*;

public class ToInstantExample {
    public static void main(String[] args) {
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        ZoneId zoneId = ZoneId.systemDefault();
        Instant instantFromDateAndTime = LocalDateTime.of(localDate, localTime).atZone(zoneId).toInstant();

        System.out.println("Instant from LocalDate and LocalTime: " + instantFromDateAndTime);
    }
}

How do I use next() and nextOrSame() method of TemporalAdjusters?

TemporalAdjusters.next(DayOfWeek) and TemporalAdjusters.nextOrSame(DayOfWeek) are part of java.time.temporal.TemporalAdjusters class in Java. They adjust the date to the next, or the first occurrence of the specified DayOfWeek, or stay at the same date if it’s the desired DayOfWeek.

Here is how to use these methods:

package org.kodejava.datetime;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

public class NextOrSameExample {
    public static void main(String[] args) {
        // Get the current date
        LocalDate date = LocalDate.now();
        System.out.println("Current date: " + date);

        LocalDate nextMonday = date.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
        System.out.println("Next Monday: " + nextMonday);

        LocalDate nextOrSameFriday = date.with(TemporalAdjusters.nextOrSame(DayOfWeek.FRIDAY));
        System.out.println("Next Friday or same day if it's Friday: " + nextOrSameFriday);
    }
}

Output:

Current date: 2024-01-18
Next Monday: 2024-01-22
Next Friday or same day if it's Friday: 2024-01-19

In the above example:

  • LocalDate.now() is used to get the current date.
  • .with(TemporalAdjusters.next(DayOfWeek.MONDAY)) adjusts the date to the next Monday.
  • .with(TemporalAdjusters.nextOrSame(DayOfWeek.FRIDAY)) adjusts the date to the next Friday or stays at the same date if it’s already Friday.

How do I use firstInMonth() and lastInMonth() method of TemporalAdjusters class?

TemporalAdjusters.firstInMonth(DayOfWeek) and TemporalAdjusters.lastInMonth(DayOfWeek) methods are part of the java.time.temporal.TemporalAdjusters class. They adjust the date to the first or last occurrence of the specified DayOfWeek in the month.

Here’s an example of how to use these methods:

package org.kodejava.datetime;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

public class FirstLastInMonthExample {
    public static void main(String[] args) {
        // Get the current date
        LocalDate date = LocalDate.now();
        System.out.println("Current date: " + date);

        LocalDate firstMondayInMonth = date.with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
        System.out.println("First Monday of this month: " + firstMondayInMonth);

        LocalDate lastFridayInMonth = date.with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY));
        System.out.println("Last Friday of this month: " + lastFridayInMonth);
    }
}

The output of the code snippet above:

Current date: 2024-01-18
First Monday of this month: 2024-01-01
Last Friday of this month: 2024-01-26

In this example:

  • LocalDate.now()` is used to get the current date.
  • .with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY)) adjusts the date to the first Monday of the current month.
  • .with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY)) adjusts the date to the last Friday of the current month.

How do I use firstDayOfYear() and firstDayOfNextYear() method of TemporalAdjusters class?

The TemporalAdjusters.firstDayOfYear() and TemporalAdjusters.firstDayOfNextYear() methods in Java are utilized to adjust a date to the first day of the current year and the first day of the next year respectively.

Here’s how to use these methods:

package org.kodejava.datetime;

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

public class FirstDayOfYearExample {
    public static void main(String[] args) {
        // Det the current date
        LocalDate date = LocalDate.now();
        System.out.println("Current date: " + date);

        LocalDate firstDayOfYear = date.with(TemporalAdjusters.firstDayOfYear());
        System.out.println("First day of this year: " + firstDayOfYear);

        LocalDate firstDayOfNextYear = date.with(TemporalAdjusters.firstDayOfNextYear());
        System.out.println("First day of next year: " + firstDayOfNextYear);
    }
}

In this example:

  • LocalDate.now() is used to get the current date.
  • .with(TemporalAdjusters.firstDayOfYear()) adjusts the date to the first day of the current year.
  • .with(TemporalAdjusters.firstDayOfNextYear()) adjusts the date to the first day of the next year.

The output of the code snippet above:

Current date: 2024-01-18
First day of this year: 2024-01-01
First day of next year: 2025-01-01

How do I use TemporalAdjusters firstDayOfNextMonth() method?

The TemporalAdjusters.firstDayOfNextMonth() method is a useful method in java.time.temporal.TemporalAdjusters class in Java that adjusts the date to the first day of the next month.

Here’s an example usage:

package org.kodejava.datetime;

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

public class FirstDayOfNextMonthExample {
    public static void main(String[] args) {
        // Get the current date
        LocalDate date = LocalDate.now();

        // Adjust to the first day of next month
        LocalDate firstDayOfNextMonth = date.with(TemporalAdjusters.firstDayOfNextMonth());

        System.out.println("Current date: " + date);
        System.out.println("First day of next month: " + firstDayOfNextMonth);
    }
}

Output:

Current date: 2024-01-18
First day of next month: 2024-02-01

In this example, LocalDate.now() is used to get the current date. Then .with(TemporalAdjusters.firstDayOfNextMonth()) is used to adjust the date to the first day of the next month.