Java time since the epoch

Question

In Java, how can I print out the time since the epoch given in seconds and nanoseconds in the following format :

java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

My input is:

long mnSeconds;
long mnNanoseconds;

Where the total of the two is the elapsed time since the epoch 1970-01-01 00:00:00.0 .

Answer 1

Use this and divide by 1000

long epoch = System.currentTimeMillis();

System.out.println("Epoch : " + (epoch / 1000));

Answer 2

You can do this

public static String format(long mnSeconds, long mnNanoseconds) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.");
    return sdf.format(new Date(mnSeconds*1000))
           + String.format("%09d", mnNanoseconds);
}

eg

2012-08-08 19:52:21.123456789

---

if you don't really need any more than milliseconds you can do

public static String format(long mnSeconds, long mnNanoseconds) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    return sdf.format(new Date(mnSeconds*1000 + mnNanoseconds/1000000));
}

Answer 3

tl;dr

    Instant                        // Represent a moment in UTC.
    .ofEpochSecond( mnSeconds )   // Determine a moment from a count of whole seconds since the Unix epoch of the first moment of 1970 in UTC (1970-01-01T00:00Z). 
    .plusNanos( mnNanoseconds )    // Add on a fractional second as a count of nanoseconds. Returns another `Instant` object, per Immutable Objects pattern.
    .toString()                    // Generate text representing this `Instant` object in standard ISO 8601 format.
    .replace( "T" , " " )          // Replace the `T` in the middle with a SPACE. 
    .replace "Z" , "" )            // Remove the `Z` on the end (indicating UTC).

java.time

The java.time framework is built into Java 8 and later. These classes supplant the old troublesome date-time classes such as java.util.Date , .Calendar , java.text.SimpleDateFormat , java.sql.Date , and more. The Joda-Time team also advises migration to java.time.

Instant

The Instant class represents a moment on the timeline in UTC with a resolution up to nanoseconds.

long mnSeconds = … ;
long mnNanoseconds = … ;

Instant instant = Instant.ofEpochSecond( mnSeconds ).plusNanos( mnNanoseconds );

Or pass both numbers to the of , as two arguments. Different syntax, same result.

Instant instant = Instant.ofEpochSecond( mnSeconds , mnNanoseconds );

To get a String representing this date-time value, call Instant::toString .

String output = instant.toString();

You will get a value such as 2011-12-03T10:15:30.987654321Z , standard ISO 8601 format. Replace the T with a SPACE if you wish. For other formats, search Stack Overflow to learn about DateTimeFormatter .

---

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date , Calendar , & SimpleDateFormat .

The Joda-Time project, now in maintenance mode , advises migration to the java.time classes.

To learn more, see the Oracle Tutorial . And search Stack Overflow for many examples and explanations. Specification is JSR 310 .

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 , and later - Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
• Java SE 6 and Java SE 7
  • Most of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport .
• Android
  • Later versions of Android bundle implementations of the java.time classes.
  • For earlier Android (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP… .

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval , YearWeek , YearQuarter , and more .

Answer 4

java.util.Date class has a constructor which accepts the epoch milliSeconds.

Check the java doc and try to make use of it.

Answer 5

It depends a bit on the values of you mnSeconds and mnNanoseconds but all you need to do with a formatter like that one (which has millisecond precision) is to create a java.util.Date. If mnNanoseconds is the number of nanoseconds on top of your mnSeconds, I would assume it to be something like

Date d = new Date(mnSeconds*1000+mnNanosecods/1000000)

Then it is a matter of formatting it with your formatter before printing it.

Answer 6

You can use

new java.util.Date(mnSeconds);

and then SimpleDateFormat to format your output.

Nanoseconds are not supported by Date. You have to manually add Nanoseconds or use some framework (is there one?).