Un liner Java

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

Dans le style JDK8

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

Il vous suffit d'ajouter le champ milliseconde dans votre chaîne de format de date:

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

Le document API de SimpleDateFormat décrit la chaîne de format en détail.

Essayez ceci:-

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));

Ou

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

Tl; dr

Instant.now()
       .toString()

2016-05-06T23:24: 25.694 Z

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

2016-05-06 19:24:25.694

Java.temps

Dans Java 8 et versions ultérieures, nous avons le java.time framework intégré dans Java 8 et versions ultérieures. Ces nouvelles classes supplantent l'ancien java gênant.util.Date/.Classes de calendrier. Les nouvelles classes sont inspirées par le très réussi Joda-Time framework, conçu comme son successeur, similaire dans le concept mais ré-architecturé. Défini par JSR 310. Le projet est étendu par le projet ThreeTen-Extra. Voir le tutoriel .

Soyez conscient que java.le temps est capable de résolutionnanoseconde (9 décimales en fraction de seconde), par rapport à la résolutionmilliseconde (3 décimales) des deux java.util.Date & Joda-Heure. Ainsi, lors du formatage pour afficher seulement 3 décimales, vous pourriez cacher des données.

Si vous voulez éliminer toutes les microsecondes ou nanosecondes de vos données, tronquer.

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

Le java.les classes de temps utilisent le format ISO 8601 par défaut lors de l'analyse/génération de chaînes. Un Z à la fin est l'abréviation de Zulu, et signifie UTC.

Un Instant représente un moment dans le scénario de l'UTC avec une résolution de jusqu'à nanosecondes. Capturer le moment actuel en Java 8 est limité à millisecondes, avec une nouvelle implémentation en Java 9 capturant jusqu'à nanosecondes selon les capacités de l'horloge matérielle de votre ordinateur.

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

2016-05-06T23:24: 25.694 Z

Remplacez le T au milieu par un espace, et le Z par rien, pour obtenir la sortie souhaitée.

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

Comme vous ne vous souciez pas d'inclure le décalage ou le fuseau horaire, créez une date-heure "locale" sans rapport avec une localité particulière.

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

Joda-Temps

Le très réussi Joda-Time library a été l'inspiration pour java.cadre de temps. Conseillé de migrer vers java.temps quand pratique.

Le format ISO 8601inclut des millisecondes, et est la valeur par défaut pour la bibliothèque Joda-Time 2.4.

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

Lors de l'exécution...

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

Vous pouvez également demander la fraction de seconde en millisecondes sous forme de nombre, si nécessaire:

int millisOfSecond = myDateTime.getMillisOfSecond ();

Pour compléter les réponses ci-dessus, voici un petit exemple de travail d'un programme qui imprime l'heure et la date actuelles, y compris les millisecondes.

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);
    }
}

J'utiliserais quelque chose comme ceci:

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

La variable dateTime peut être n'importe quelle valeur de date et / ou d'heure, voir JavaDoc pour Formatter.

Le moyen le plus simple était (avant Java 8) d'utiliser,

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

, Mais SimpleDateFormat n'est pas thread-safe. Ni java.util.Date. Cela conduira à des problèmes de concurrence potentiels pour les utilisateurs. Et il y a beaucoup de problèmes dans ces conceptions existantes. Pour les surmonter maintenant dans Java 8, nous avons un paquet séparé appelé java.temps. Ce document Java SE 8 Date et Heure a un bon aperçu à ce sujet.

Donc en Java 8 quelque chose comme ci-dessous fera l'affaire (pour formater la date/heure actuelle),

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

Et une chose à noter est qu'il a été développé avec l'aide de la bibliothèque tierce populaire joda-time ,

Le projet a été mené conjointement par l'auteur de Joda-Time (Stephen Colebourne) et Oracle, sous JSR 310, et apparaîtra dans le nouveau paquet Java SE 8 java.temps.

Mais maintenant le joda-time devient obsolète et a demandé aux utilisateurs de migrer vers le nouveau java.time.

Remarque qu'à partir de Java SE 8, les utilisateurs sont invités à migrer vers java.time (JSR-310) - une partie centrale du JDK qui remplace ce projet

Quoi qu'il en soit,

Si vous avez un Agenda exemple, vous pouvez utiliser ci-dessous pour convertir à la nouvelle - 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

Si vous aviez un objet Date,

    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

Si vous venez d'avoir les millisecondes d'époque,

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

Vous pouvez simplement l'obtenir dans le format que vous voulez.

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

Le document dans Java 8 le nomme fraction de seconde, tandis que dans Java 6 était nommé milliseconde. Cela m'a amené à la confusion