In Java, we can have many different ways to get the current timestamp, but which one is recommended:
Instant.now().toEpochMilli()
or System.currentTimeMillis()
Both are fine. And neither is recommended except for a minority of purposes.
In Java, we can have many different ways to get the current timestamp,
For current timestamp just use Instant.now()
. No need to convert to milliseconds.
Many methods from the first years of Java, also many in the standard library, took a long
number of milliseconds since the epoch as argument. However, today I would consider that old-fashioned. See if you can find — or create — or more modern method that takes for instance an Instant
as argument instead. Go object-oriented and don’t use a primitive long
. It will make your code clearer and more self-explanatory.
As Eliott Frisch said in a comment, if this is for measuring elapsed time, you may prefer the higher resolution of System.nanoTime()
.
Assuming that you have good reasons for wanting a count of milliseconds since the epoch, …
which one is recommended:
Instant.now().toEpochMilli()
orSystem.currentTimeMillis()
[?]
Opinions differ. Some will say that you should use java.time, the modern date and time API, for all of your date and time work. This would imply Instant
here. Unsg java.time is generally a good habit since the date and time classes from Java 1.0 and 1.1 (Date
, Calendar
, TimeZone
, DateFormat
, SimpleDateFormat
and others) are poorly designed and now long outdated, certainly not any that we should use anymore. On the other hand I am not aware of any design problem with System.curremtTimeMillis()
in particular (except what I mentioned above about using a long
count of milliseconds at all, which obviously is intrinsic to both Instant.now().toEpochMilli()
and System.currentTimeMillis()
).
If there is a slight performance difference between the two, I have a hard time imagining the situation where this will matter.
Take the option that you find more readable and less surprising in your context.
As per my understanding Instant.now().toEpochMilli()
is better as Java-8 onward usage of Instant
has been recommended.
Also, it works based on timeline and instant represents a specific moment on that timeline.
In case of java.lang.System.currentTimeMillis()
method it returns the current time in milliseconds. The granularity of the value depends on the underlying operating system and may be larger.
Hence, to be consistent altogether use Instant
.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With