The first was born in the UK while the second in California. Consider the following example: two persons which were born at 11am, July the 2nd 2013. But there is a difference: LocalDateTime is not a point on the time line as Instant is, LocalDateTime is just a date and time as a person would write on a note. LocalDateTime seems to be very similar to Instant, a reminder: "an Instant is point in time without time zone” and one could say that a point in time is nothing more than a date and time within that date. The last important player in the simple date and time classes is LocalDateTime - this is a combination of LocalDate and LocalTime representing a date and the time within that date, again no time zone. LocalDate localDate1 = us(5, ChronoUnit.HOURS) LocalDate and LocalTime have calculation and comparison methods similar to the ones Instant has (some of the methods are defined by the interface which implemented by all of these classes): LocalDate and Local time follow the same general concept of multithreading as Instant does - and as such their instances are immutable. LocalTime = LocalTime.ofSecondOfDay(4503) // The 4,503 second in a day (1:15:30 AM) LocalTime localTime = LocalTime.of(22, 33) //10:33 PM LocalDate = LocalDate.of(2013, Month.AUGUST, 10) //10th of Aug 2013 There are several ways to obtain LocalTime and LocalDate instances, here are few: LocalTime represents time without a time zone, such as 04:44:59.12 - unlike Instant which is an offset from the Java epoch and as such can be calculated into a precise point of time these two are just date or time without any relation to the epoch - a human readable date and time. LocalDate represents a date without a time zone, such as 1-1-2000. Instant1.isAfter(instant)=true, instant1.isBefore(instant)=false. Instant1.isAfter(instant), instant1.isBefore(instant))
("instant1.isAfter(instant)=%b, instant1.isBefore(instant)=%b.%n", We can check to see which Instant is before/after the other ("pareTo(instant)=%d.%n", pareTo(instant)) Instant also provides the isAfter() and isBefore() methods which can make a more readable code: Instants are Comparable which means they can be used in any place a Comparable is expected (such as collections). Long diffAsMinutes = (instant, instant1) // Option 2 Long diffAsMinutes = instant.periodUntil(instant1, ChronoUnit.MINUTES) // Option 1 How many minutes are between to Instants? Instant.minus(Duration.ofDays(5)) // Option 2 Instant.minus(5, ChronoUnit.DAYS) // Option 1 Here are few more examples of Instant calculations: Instant is immutable, so instant=instant returns: false ("Instant is immutable, so instant=instant returns: " + (instant = instant1)) Instant instant1 = us(Duration.ofHours(5).plusMinutes(4)) The java.time package is planned to be thread safe and as such most of its classes are immutable, Instant is not an exception to that rule and as such the plus() method creates a new instance. How many instances of are used in the example above? Two. Adding 5 hours and 4 minutes to an Instant
Instant API provides some useful methods to allow calculations using Instants and other classes in the package, below is a first example: The second example above creates an Instant by parsing a String, this string must by a valid representation of a UTC Instant (NB: Instant is a point of time, it doesn't store any TimeZone information and as such it supports only UTC formatted strings). Instant instant = Instant.ofEpochMilli(new Date().getTime()) Here are some other ways to create Instants: Instant.toString() returns a ISO8601 formatted string (such as: 'T16:22:52.966Z'), a much more logical choice than the one used by the old Date class. Let's start with obtaining an Instant instance and print its value: Representing a point in time using nanoseconds precision requires more space than a Long can provide, therefore the internal representation is composed of two Long fields, the first holds the number of seconds since (or before) the standard Java epoch and the other the number of nanoseconds of the last seconds (so never larger than 999,999,999). An Instant represents a point in time (similar to ) with nanoseconds precision (unlike the old Date which has milliseconds precision). Probably the best place to start with the java.time package is the Instant class.
This post would be the first in a series, starting with some basic classes of the package: Instant, LocalDate, LocalTime, and LocalDateTime. As there is much to cover in this new long awaited API I think it worth few posts with some examples.
I started to experience the Java 8 new APIs (still Early Access at the moment of writing this post) and the first thing I looked into was the new date and time API ( JSR 310).
0 kommentar(er)
