The Instant class is a part of the java.time package introduced in Java 8. It represents an instant in time with nanosecond precision.
An Instant object can be created in a few different ways. One way is to call the now method, which returns the current instant:
Instant now = Instant.now();
Another way is to parse a string that represents an instant in the ISO-8601 format:
Instant instant = Instant.parse("2019-07-01T12:30:45.123456Z");
The Instant class provides methods for performing arithmetic operations with other Instant objects or with Duration objects. For example, you can add or subtract a Duration to or from an Instant:
Instant instant = Instant.parse("2019-07-01T12:30:45.123456Z");
Duration fiveMinutes = Duration.ofMinutes(5);
Instant later = instant.plus(fiveMinutes);
Instant earlier = instant.minus(fiveMinutes);
You can also compare Instant objects to see which one comes before or after another:
Instant instant1 = Instant.parse("2019-07-01T12:30:45.123456Z");
Instant instant2 = Instant.parse("2019-07-01T12:30:50.123456Z");
boolean isBefore = instant1.isBefore(instant2);
boolean isAfter = instant1.isAfter(instant2);
Note that Instant objects are immutable, meaning that their values cannot be changed once they are created.
Java Instant Class Declaration:
The Instant class in Java is declared as follows:
public final class Instant
implements Temporal, TemporalAdjuster, Comparable<Instant>, Serializable
Here, we can see that the Instant class is marked as final, which means that it cannot be extended or subclassed. It implements several interfaces, including Temporal, TemporalAdjuster, Comparable, and Serializable.
The Temporal and TemporalAdjuster interfaces are part of the java.time package and define methods for manipulating and querying temporal objects, such as dates, times, and durations. The Comparable interface allows Instant objects to be compared with each other. The Serializable interface enables Instant objects to be serialized and deserialized, which is useful for saving and loading objects to and from streams.
Overall, the Instant class provides a convenient way to represent an instant in time with nanosecond precision and perform various operations with it, such as adding or subtracting durations and comparing with other instants.
Methods of Java Instant:
The Instant class in Java provides a variety of methods to work with and manipulate instant objects. Some of the commonly used methods are:
now(): Returns the current instant in time.
Instant now = Instant.now();
ofEpochSecond(long epochSecond): Returns anInstantobject representing the given epoch second, with zero nanosecond.
Instant instant = Instant.ofEpochSecond(1612451682);
ofEpochSecond(long epochSecond, long nanoAdjustment): Returns anInstantobject representing the given epoch second with an additional nanosecond adjustment.
Instant instant = Instant.ofEpochSecond(1612451682, 500000000);
parse(CharSequence text): Parses the text in the ISO-8601 format and returns anInstantobject.
Instant instant = Instant.parse("2021-02-04T15:41:22.123Z");
getEpochSecond(): Returns the number of seconds from the epoch of 1970-01-01T00:00:00Z.
long epochSeconds = instant.getEpochSecond();
getNano(): Returns the number of nanoseconds, later along the time-line, from the start of the second.
int nanos = instant.getNano();
plus(Duration amountToAdd): Returns a newInstantobject, which is the result of adding the specified duration to this instant.
Instant newInstant = instant.plus(Duration.ofHours(1));
minus(Duration amountToSubtract): Returns a newInstantobject, which is the result of subtracting the specified duration from this instant.
Instant newInstant = instant.minus(Duration.ofMinutes(30));
isBefore(Instant otherInstant): Returns true if this instant is before the specified instant.
boolean before = instant1.isBefore(instant2);
isAfter(Instant otherInstant): Returns true if this instant is after the specified instant.
boolean after = instant1.isAfter(instant2);
These are some of the commonly used methods of the Instant class in Java. The class provides several other methods for working with instant objects, such as truncatedTo(), compareTo(), and toEpochMilli().
Java Instant Example: parse()
Sure, here’s an example of using the Instant.parse() method to create an Instant object from a string in the ISO-8601 format:
import java.time.Instant;
public class InstantExample {
public static void main(String[] args) {
String str = "2021-05-06T14:30:30.123456Z";
Instant instant = Instant.parse(str);
System.out.println("Instant created from string: " + instant);
}
}
In this example, we first declare a string variable str that represents an instant in the ISO-8601 format. Then, we call the Instant.parse() method, passing the string as an argument, to create an Instant object. Finally, we print the Instant object using the System.out.println() method.
The output of this example would be:
Instant created from string: 2021-05-06T14:30:30.123456Z
This shows that we have successfully created an Instant object from the string using the parse() method. Note that the Z at the end of the string represents the UTC time zone.
Java Instant Example: now()
Sure, here’s an example of using the Instant.now() method to get the current instant:
import java.time.Instant;
public class InstantExample {
public static void main(String[] args) {
Instant instant = Instant.now();
System.out.println("Current Instant: " + instant);
}
}
In this example, we simply call the Instant.now() method to get the current instant and assign it to an Instant object. Then, we print the Instant object using the System.out.println() method.
The output of this example would be similar to the following, as the current instant is constantly changing:
Current Instant: 2023-05-06T18:30:45.123456Z
This shows that we have successfully obtained the current instant using the now() method of the Instant class.
Java Instant Example: minus()
Sure, here’s an example of using the Instant.minus() method to subtract a Duration from an Instant:
import java.time.Duration;
import java.time.Instant;
public class InstantExample {
public static void main(String[] args) {
Instant now = Instant.now();
Instant earlier = now.minus(Duration.ofMinutes(30));
System.out.println("30 minutes earlier: " + earlier);
}
}
In this example, we first obtain the current instant using the Instant.now() method and assign it to an Instant object called now. Then, we use the minus() method to subtract a Duration of 30 minutes from the current instant, resulting in an Instant object called earlier. Finally, we print the earlier instant using the System.out.println() method.
The output of this example would be similar to the following, as the exact instant is constantly changing:
30 minutes earlier: 2023-05-06T18:00:45.123456Z
This shows that we have successfully used the minus() method of the Instant class to subtract a Duration from an Instant.
Java Instant Example: plus()
Sure, here’s an example of using the Instant.plus() method to add a Duration to an Instant:
import java.time.Duration;
import java.time.Instant;
public class InstantExample {
public static void main(String[] args) {
Instant now = Instant.now();
Instant later = now.plus(Duration.ofHours(3));
System.out.println("3 hours later: " + later);
}
}
In this example, we first obtain the current instant using the Instant.now() method and assign it to an Instant object called now. Then, we use the plus() method to add a Duration of 3 hours to the current instant, resulting in an Instant object called later. Finally, we print the later instant using the System.out.println() method.
The output of this example would be similar to the following, as the exact instant is constantly changing:
3 hours later: 2023-05-06T21:30:45.123456Z
This shows that we have successfully used the plus() method of the Instant class to add a Duration to an Instant.
Java Instant Example: isSupported()
Sure, here’s an example of using the Instant.isSupported() method to check if a field is supported by an Instant:
import java.time.Instant;
import java.time.temporal.ChronoField;
public class InstantExample {
public static void main(String[] args) {
Instant now = Instant.now();
boolean isSupported = now.isSupported(ChronoField.MONTH_OF_YEAR);
System.out.println("Is Month of Year supported? " + isSupported);
}
}
In this example, we first obtain the current instant using the Instant.now() method and assign it to an Instant object called now. Then, we use the isSupported() method to check if the MONTH_OF_YEAR field is supported by the Instant. This field represents the month-of-year, from 1 to 12. Finally, we print the result of the check using the System.out.println() method.
The output of this example would be:
Is Month of Year supported? false
This shows that the MONTH_OF_YEAR field is not supported by the Instant class. Note that this is because an Instant represents an instantaneous point on the time-line and does not have any notion of fields such as year, month, day, etc.