How to get the current time in YYYY-MM-DD HH:MI:Sec.Millisecond format in Java?

Question

The code below gives me the current time. But it does not tell anything about milliseconds.

public static String getCurrentTimeStamp() {
    SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//dd/MM/yyyy
    Date now = new Date();
    String strDate = sdfDate.format(now);
    return strDate;
}

I have a date in the format YYYY-MM-DD HH:MM:SS (2009-09-22 16:47:08).

But I want to retrieve the current time in the format YYYY-MM-DD HH:MM:SS.MS (2009-09-22 16:47:08.128, where 128 are the milliseconds).

SimpleTextFormat will work fine. Here the lowest unit of time is second, but how do I get millisecond as well?

Preponderant

When all else fails, read the documentation. – Herzel

FYI, the troublesome old date-time classes such as java.util.Date, java.util.Calendar, and java.text.SimpleTextFormat are now legacy, supplanted by the java.time classes. See Tutorial by Oracle. – Kohinoor

This question is 15 years old (and counting), so beware of many outdated answers. Use the answers that use java.time, the modern Java date and time API, and its ZonedDateTime and DateTimeFormatter classes. The SimpleDateFormat class used in many of the answers was a notorious troublemaker of a class and has been outdated for 10 years. Definitely avoid it. – Earthwork

Answer 1

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

Thereunder

Out of curiosity, what benefit does using SimpleDateFormat bring over just: dateTime.ToString("yyyy-MM-dd HH:mm:ss.SSS") ? – Mandimandible

@Mandimandible Where is this toString(String format) method? The java.util.Date doesn't seem to have it. Are you referring to the Joda Time API? But one possible benefit is reuse of the same formatter object. Another is you don't have to add an API - Date class is a standard Java library class. – Dillard

In Java 8 you can use DateTimeFormatter for the same purpose. – Acree

SimpleDateFormat is not thread safe, but the newer DateTimeFormatter is thread safe. – Delwyn

Using Java 8 datetime API: LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")) – Kohn

I found this one for Date SimpleDateFormat.getDateInstance(DateFormat.SHORT) but seems there is no template for Time and Date at the same time – Entrust

FYI, the terribly troublesome old date-time classes such as java.util.Date, java.util.Calendar, and java.text.SimpleDateFormat are now legacy, supplanted by the java.time classes built into Java 8 and later. See Tutorial by Oracle. – Kohinoor

VERY Important to note that it is NOT the same behavior as the regular Oracle Java library. Oracle Java will show 3 digits for ".S", as it stands specifically for milliseconds. Whereas Android ".S" stands for fractions of seconds. With Oracle Java you can only use one "S" (and always shows 3 digits), but in Android you can use any number of "S" characters you require, one digit shown per "S". – Baresark

The below answer (public String getCurrentTimeStamp() { return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()); }) should have more upvotes than this one. More people will want the string rather than just the SimpleDateFormat object. – Intolerant

Answer 2

A Java one liner

public String getCurrentTimeStamp() {
    return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date());
}

in JDK8 style

public String getCurrentLocalDateTimeStamp() {
    return LocalDateTime.now()
       .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));
}

Douglasdouglashome

LocalDateTime and DateTimeFormatter are thread-safe unlike SimpleDateFormat – Peele

@Peele any case where SimpleDateFormat cause issues? – Breslau

@gaurav here is your cookie: callicoder.com/java-simpledateformat-thread-safety-issues – Patrology

But both of the examples are thread safe or did I miss something? – Sneaking

yes, the examples are thread safe. A new SimpleDateFormat is created every time. – Douglasdouglashome

This answer should have more upvotes; most people want the result String like me rather than just the SimpleDateFormat object – Intolerant

Call requires API level 26 – Recreation

Answer 3

You only have to add the millisecond field in your date format string:

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

The API doc of SimpleDateFormat describes the format string in detail.

Pa

Answer 4

try this:-

http://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html

DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
Date date = new Date();
System.out.println(dateFormat.format(date));

or

DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Calendar cal = Calendar.getInstance();
System.out.println(dateFormat.format(cal.getTime()));

Surrogate

Answer 5

tl;dr

Instant.now()
       .toString()

2016-05-06T23:24:25.694Z

ZonedDateTime
.now
( 
    ZoneId.of( "America/Montreal" ) 
)
.format(  DateTimeFormatter.ISO_LOCAL_DATE_TIME )
.replace( "T" , " " )

2016-05-06 19:24:25.694

java.time

In Java 8 and later, we have the java.time framework built into Java 8 and later. These new classes supplant the troublesome old java.util.Date/.Calendar classes. The new classes are inspired by the highly successful Joda-Time framework, intended as its successor, similar in concept but re-architected. Defined by JSR 310. Extended by the ThreeTen-Extra project. See the Tutorial.

Be aware that java.time is capable of nanosecond resolution (9 decimal places in fraction of second), versus the millisecond resolution (3 decimal places) of both java.util.Date & Joda-Time. So when formatting to display only 3 decimal places, you could be hiding data.

If you want to eliminate any microseconds or nanoseconds from your data, truncate.

Instant instant2 = instant.truncatedTo( ChronoUnit.MILLIS ) ;

The java.time classes use ISO 8601 format by default when parsing/generating strings. A Z at the end is short for Zulu, and means UTC.

An Instant represents a moment on the timeline in UTC with resolution of up to nanoseconds. Capturing the current moment in Java 8 is limited to milliseconds, with a new implementation in Java 9 capturing up to nanoseconds depending on your computer’s hardware clock’s abilities.

Instant instant = Instant.now (); // Current date-time in UTC.
String output = instant.toString ();

2016-05-06T23:24:25.694Z

Replace the T in the middle with a space, and the Z with nothing, to get your desired output.

String output = instant.toString ().replace ( "T" , " " ).replace( "Z" , "" ; // Replace 'T', delete 'Z'. I recommend leaving the `Z` or any other such [offset-from-UTC][7] or [time zone][7] indicator to make the meaning clear, but your choice of course.

2016-05-06 23:24:25.694

As you don't care about including the offset or time zone, make a "local" date-time unrelated to any particular locality.

String output = LocalDateTime.now ( ).toString ().replace ( "T", " " );

Joda-Time

The highly successful Joda-Time library was the inspiration for the java.time framework. Advisable to migrate to java.time when convenient.

The ISO 8601 format includes milliseconds, and is the default for the Joda-Time 2.4 library.

System.out.println( "Now: " + new DateTime ( DateTimeZone.UTC ) );

When run…

Now: 2013-11-26T20:25:12.014Z

Also, you can ask for the milliseconds fraction-of-a-second as a number, if needed:

int millisOfSecond = myDateTime.getMillisOfSecond ();

Kohinoor

Instant.now().toString() Call requires API level 26 – Recreation

@HarishGyanani (a) This Question is for the Java platform, not Android. (b) Incorrect. With modern tooling, “API desugaring” provides earlier Android with access to most of the java.time functionality. developer.android.com/studio/write/java8-support-table – Kohinoor

Answer 6

I would use something like this:

String.format("%tF %<tT.%<tL", dateTime);

Variable dateTime could be any date and/or time value, see JavaDoc for Formatter.

Subbase

Yeah, but you have to use multiple copies of same argument, like this: String.format("%tF %<tT.%<tL", dateTime, dateTime, dateTime); – Biliary

No, you do not. The character < indicates to use the previous argument and not the next one... – Subbase

Answer 7

The easiest way was to (prior to Java 8) use,

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

But SimpleDateFormat is not thread-safe. Neither java.util.Date. This will lead to leading to potential concurrency issues for users. And there are many problems in those existing designs. To overcome these now in Java 8 we have a separate package called java.time. This Java SE 8 Date and Time document has a good overview about it.

So in Java 8 something like below will do the trick (to format the current date/time),

LocalDateTime.now()
   .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));

And one thing to note is it was developed with the help of the popular third party library joda-time,

The project has been led jointly by the author of Joda-Time (Stephen Colebourne) and Oracle, under JSR 310, and will appear in the new Java SE 8 package java.time.

But now the joda-time is becoming deprecated and asked the users to migrate to new java.time.

Note that from Java SE 8 onwards, users are asked to migrate to java.time (JSR-310) - a core part of the JDK which replaces this project

Anyway having said that,

If you have a Calendar instance you can use below to convert it to the new java.time,

    Calendar calendar = Calendar.getInstance();
    long longValue = calendar.getTimeInMillis();         

    LocalDateTime date =
            LocalDateTime.ofInstant(Instant.ofEpochMilli(longValue), ZoneId.systemDefault());
    String formattedString = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));

    System.out.println(date.toString()); // 2018-03-06T15:56:53.634
    System.out.println(formattedString); // 2018-03-06 15:56:53.634

If you had a Date object,

    Date date = new Date();
    long longValue2 = date.getTime();

    LocalDateTime dateTime =
            LocalDateTime.ofInstant(Instant.ofEpochMilli(longValue2), ZoneId.systemDefault());
    String formattedString = dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));

    System.out.println(dateTime.toString()); // 2018-03-06T15:59:30.278
    System.out.println(formattedString);     // 2018-03-06 15:59:30.278

If you just had the epoch milliseconds,

LocalDateTime date =
        LocalDateTime.ofInstant(Instant.ofEpochMilli(epochLongValue), ZoneId.systemDefault());

Overstrung

minimum API level is 26 – Negation

Answer 8

I have a simple example here to display date and time with Millisecond......

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class MyClass{

    public static void main(String[]args){
        LocalDateTime myObj = LocalDateTime.now();
        DateTimeFormatter myFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
        String forDate = myObj.format(myFormat);
        System.out.println("The Date and Time are: " + forDate);
    }
}

Catherine

Looks good, but does it add insight over, say, rsinha's 5-year-old comment? – Squill

@Squill That comment has long deserved to be an answer. +1 – Earthwork

(@Earthwork It took me a 2nd take of your comment to see what you probably meant. Yes, I would have upvoted this answer instead of naggling above if this answer contained a reference to/credited that comment.) – Squill

Answer 9

To complement the above answers, here is a small working example of a program that prints the current time and date, including milliseconds.

import java.text.SimpleDateFormat;
import java.util.Date;

public class test {
    public static void main(String argv[]){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date now = new Date();
        String strDate = sdf.format(now);
        System.out.println(strDate);
    }
}

Debag

Answer 10

Use this to get your current time in specified format :

 DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 System.out.print(dateFormat.format(System.currentTimeMillis()));  }

Virginity

FYI, the terribly troublesome old date-time classes such as java.util.Date, java.util.Calendar, and java.text.SimpleDateFormat are now legacy, supplanted by the java.time classes built into Java 8 and later. See Tutorial by Oracle. – Kohinoor

Actually I was using this solution for Android App , but to use Java.time class in Android we need to have API set to at least 27. Anyway thanks for sharing the information. – Virginity

Nearly all of the java.time functionality is back-ported to Java 6 & 7 in the ThreeTen-Backport project with virtually the same API. Further adapted to Android <26 in the ThreeTenABP project. So there is no reason to ever touch those bloody awful old date-time classes again. – Kohinoor

Answer 11

java.time

The question and the accepted answer use java.util.Date and SimpleDateFormat which was the correct thing to do in 2009. In Mar 2014, the java.util date-time API and their formatting API, SimpleDateFormat were supplanted by the modern date-time API. Since then, it is highly recommended to stop using the legacy date-time API.

Solution using java.time, the modern date-time API:

LocalDateTime.now(ZoneId.systemDefault())
             .format(DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss.SSS"))

Some important points about this solution:

1. Replace ZoneId.systemDefault() with the applicable ZoneId e.g. ZoneId.of("America/New_York").
2. If the current date-time is required in the system's default timezone (ZoneId), you do not need to use LocalDateTime#now(ZoneId zone); instead, you can use LocalDateTime#now().
3. You can use y instead of u here but I prefer u to y.

Demo:

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Locale;

class Main {
    public static void main(String args[]) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("uuuu-MM-dd HH:mm:ss.SSS", Locale.ENGLISH);
        // Replace ZoneId.systemDefault() with the applicable ZoneId e.g.
        // ZoneId.of("America/New_York")
        LocalDateTime ldt = LocalDateTime.now(ZoneId.systemDefault());
        String formattedDateTimeStr = ldt.format(formatter);
        System.out.println(formattedDateTimeStr);
    }
}

Output from a sample run in my system's timezone, Europe/London:

2023-01-02 09:53:14.353

ONLINE DEMO

Learn more about the modern Date-Time API from Trail: Date Time.

Brussels

Answer 12

I don't see a reference to this:

SimpleDateFormat f = new SimpleDateFormat("yyyyMMddHHmmssSSS");

above format is also useful.

http://www.java2s.com/Tutorials/Java/Date/Date_Format/Format_date_in_yyyyMMddHHmmssSSS_format_in_Java.htm

Sophomore

Answer 13

Ans:

DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
ZonedDateTime start = Instant.now().atZone(ZoneId.systemDefault());
String startTimestamp = start.format(dateFormatter);

Witting

Answer 14

java.text (prior to java 8)

public static ThreadLocal<DateFormat> dateFormat = new ThreadLocal<DateFormat>() {
    protected DateFormat initialValue() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    };
};

...
dateFormat.get().format(new Date());

java.time

public static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");

...
dateTimeFormatter.format(LocalDateTime.now());

Folkestone

Answer 15

The doc in Java 8 names it fraction-of-second , while in Java 6 was named millisecond. This brought me to confusion

Avertin

Answer 16

You can also use the DateTimeFormatter class from java.time.format.DateTimeFormatter package to format the required pattern.

public static String getTimeStamp() {
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd-HH-mm-ss.SSS");
    return LocalDateTime.now().format(dateTimeFormatter);
}

Lightyear

Answer 17

You can simply get it in the format you want.

String date = String.valueOf(android.text.format.DateFormat.format("dd-MM-yyyy", new java.util.Date()));

Capitalization