Si vous avez juste besoin de sortir un horodatage au format AAAA. MM. JJ-HH. MM. SS (cas très fréquent), voici la façon de le faire:

String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime());

Si vous voulez la date actuelle comme chaîne, essayez ceci:

DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
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()));

Http://www.mkyong.com/java/java-how-to-get-current-date-time-date-and-calender/

Dans Java 8, il est:

LocalDateTime.now()

Et au cas où vous auriez besoin d'informations sur le fuseau horaire:

ZonedDateTime.now()

Et si vous souhaitez imprimer une chaîne formatée fantaisie:

System.out.println(ZonedDateTime.now().format(DateTimeFormatter.RFC_1123_DATE_TIME))

Il suffit de créer un objet Date...

Date date = new Date();

    // 2015/09/27 15:07:53
    System.out.println( new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime()) );

    // 15:07:53
    System.out.println( new SimpleDateFormat("HH:mm:ss").format(Calendar.getInstance().getTime()) );

    // 09/28/2015
    System.out.println(new SimpleDateFormat("MM/dd/yyyy").format(Calendar.getInstance().getTime()));

    // 20150928_161823
    System.out.println( new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime()) );

    // Mon Sep 28 16:24:28 CEST 2015
    System.out.println( Calendar.getInstance().getTime() );

    // Mon Sep 28 16:24:51 CEST 2015
    System.out.println( new Date(System.currentTimeMillis()) );

    // Mon Sep 28
    System.out.println( new Date().toString().substring(0, 10) );

    // 2015-09-28
    System.out.println( new java.sql.Date(System.currentTimeMillis()) );

    // 14:32:26
    Date d = new Date();
    System.out.println( (d.getTime() / 1000 / 60 / 60) % 24 + ":" + (d.getTime() / 1000 / 60) % 60 + ":" + (d.getTime() / 1000) % 60 );

    // 2015-09-28 17:12:35.584
    System.out.println( new Timestamp(System.currentTimeMillis()) );

    // Java 8

    // 2015-09-28T16:16:23.308+02:00[Europe/Belgrade]
    System.out.println( ZonedDateTime.now() );

    // Mon, 28 Sep 2015 16:16:23 +0200
    System.out.println( ZonedDateTime.now().format(DateTimeFormatter.RFC_1123_DATE_TIME) );

    // 2015-09-28
    System.out.println( LocalDate.now(ZoneId.of("Europe/Paris")) ); // rest zones id in ZoneId class

    // 16
    System.out.println( LocalTime.now().getHour() );

    // 2015-09-28T16:16:23.315
    System.out.println( LocalDateTime.now() );

Tl; dr

Instant.now()                                         // Capture the current moment in UTC, with a resolution of nanoseconds.

... ou ...

ZonedDateTime.now( ZoneId.of( "America/Montreal" ) )  // Capture the current moment as seen in the wall-clock time used by the people of a particular region (a time zone).

Java.temps

Quelques-unes des réponses mentionnent que java.les classes time sont le remplacement moderne des anciennes classes date-heure héritées gênantes fournies avec les premières versions de Java. Voici un peu plus d'informations.

Fuseau horaire

Les autres réponses n'expliquent pas en quoi un fuseau horaire est crucial pour déterminer la date et l'heure actuelles. Pour un moment donné, la date et l'heure varient dans le monde entier par zone. Par exemple, quelques minutes après minuit est un nouveau jour à Paris France tout en étant "hier" à Montréal Québec .

Instant

Une grande partie de votre logique métier et de votre stockage/échange de données devrait être effectuée en UTC, en tant que meilleure pratique. Pour obtenir le moment actuel dans UTC, avec une résolution de nanosecondes, utiliser Instant classe.

Instant instant = Instant.now();

ZonedDateTime

Vous pouvez ajuster cela Instant dans d'autres fuseaux horaires. Appliquer une ZoneId objet pour obtenir un ZonedDateTime.

ZoneId z = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = instant.atZone( z );

Nous pouvons ignorer le Instant et obtenir directement le ZonedDateTime actuel.

ZonedDateTime zdt = ZonedDateTime.now( z );

Passez toujours cet argument de fuseau horaire facultatif. S'il est omis, le fuseau horaire par défaut actuel de votre JVM est appliqué. La valeur par défaut peut changer à n'importe quel moment, même pendant l'exécution. Ne pas soumettre votre application à une externalité hors de votre contrôle. Spécifiez toujours l'heure souhaitée / attendue zone.

ZonedDateTime do_Not_Do_This = ZonedDateTime.now(); // BAD - Never rely implicitly on the current default time zone.

Vous pouvez ensuite extraire un Instant de la ZonedDateTime.

Instant instant = zdt.toInstant();

, utilisez Toujours un Instant ou ZonedDateTime, plutôt que d'un LocalDateTime lorsque vous voulez un moment sur la timeline. Les types Local… n'ont délibérément aucun concept de fuseau horaire, ils ne représentent donc qu'une idée approximative d'un moment possible. Pour obtenir un moment réel, vous devez attribuer un fuseau horaire pour transformer les types Local… en ZonedDateTime et ainsi le rendre significatif.

LocalDate

Le LocalDate la classe représente une valeur de date uniquement sans heure et sans fuseau horaire.

ZoneId z = ZoneId.of( "America/Montreal" );
LocalDate today = LocalDate.now( z );  // Always pass a time zone.

Chaînes

Pour générer une chaîne représentant la valeur date-heure, appelez simplement toString sur java.classes de temps pour les formats standard ISO 8601.

String output = myLocalDate.toString();  // 2016-09-23

... ou ...

String output = zdt.toString();  // 2016-09-23T12:34:56.789+03:00[America/Montreal]

La classe ZonedDateTime étend le format standard en ajoutant judicieusement le nom du fuseau horaire entre crochets.

Pour les autres formats, rechercher Stack Overflow pour de nombreuses Questions et Réponses sur l'DateTimeFormatter classe.

Éviter LocalDateTime

Contrairement au commentaire de RamanSB sur la question, vous ne devriez pas utiliser LocalDateTime classe pour la date-heure actuelle.

Le LocalDateTime manque délibérément d'informations sur le fuseau horaire ou le décalage par rapport à l'UTC. Donc, c'est pas approprié lorsque vous suivez un moment précis sur la chronologie. Certainement pas approprié pour capturer le moment actuel.

Le libellé "local" est contre-intuitif. Cela signifie toute localité plutôt qu'une localité spécifique. Par exemple, Noël cette année commence à minuit le 25 décembre: 2017-12-25T00:00:00, pour être représenté comme un LocalDateTime. Mais cela signifie minuit à divers endroits du globe à différents moments. Minuit arrive d'abord dans Kiribati, plus tard en Nouvelle-Zélande, des heures plus tard en Inde, et ainsi de suite, avec plusieurs heures de plus avant le début de Noël en France quand les enfants au Canada attendent toujours ce jour-là. Chacun de ces points de départ de Noël serait représenté comme un ZonedDateTime distinct.

De l'extérieur de votre système

Si vous ne pouvez pas faire confiance à votre horloge système, voir Java: Obtenir la date et l'heure actuelles du serveur et non de l'horloge système et ma réponse .

java.time.Clock

Pour exploiter un autre fournisseur du moment actuel, écrivez une sous-classe de le résumé java.time.Clock classe.

Vous pouvez passer votre implémentation Clockcomme argument aux différents java.temps méthodes. Par exemple, Instant.now( clock ).

Instant instant = Instant.now( yourClockGoesHere ) ;

À des fins de test, notez les implémentations alternatives de Clock disponibles statiquement à partir de Clock lui-même: fixed, offset, tick, et plus encore.

À propos de java.temps

Le java.temps framework est intégré à Java 8 et plus tard. Ces classes permettent d'éviter la pénible vieux héritage date-heure classes telles que java.util.Date, Calendar, & SimpleDateFormat.

Le Joda-Temps le projet, maintenant en mode de maintenance, conseille la migration vers le java.temps classes.

Pour en savoir plus, voir le Tutoriel Oracle. Et rechercher Stack Overflow pour de nombreux exemples et explications. La spécification est JSR 310.

, Vous pouvez échanger java.temps objets directement avec votre base de données. Utilisez un pilote JDBC compatible avec JDBC 4.2 ou version ultérieure. Pas besoin de chaînes, pas besoin de classes java.sql.*.

Où obtenir le java.les classes de temps?

• Java SE 8, Java SE 9, et plus tard
  • Intégré.
  • Partie de l'API Java standard avec un application.
  • Java 9 ajoute quelques fonctionnalités et corrections mineures.
• Java SE 6 et Java SE 7
  • Une grande partie du java.fonction temps est de retour, porté à Java 6 et 7ThreeTen-Backport.
• Android
  • Versions ultérieures des implémentations Android bundle de java.les classes de temps.
  • Pour plus tôt Android, le Troisabp le projet adapte ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP....

Le Trois-Extra le projet étend java.temps avec des cours supplémentaires. Ce projet est un terrain d'essai pour d'éventuels ajouts futurs à java.temps. Vous pouvez trouver quelques classes utiles ici comme Interval, YearWeek, YearQuarter, et plus.

Utilisation:

String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime());
System.out.println(timeStamp );

(Ça marche.)

Il existe de nombreuses méthodes différentes:

• Système.Actuellemillis()
• Date
• Calendrier

Créez un objet de date et imprimez-le simplement.

Date d = new Date(System.currentTimeMillis());
System.out.print(d);

Avez-vous regardé java.util.Date? C'est exactement ce que vous voulez.

Similaire aux solutions ci-dessus. Mais je me retrouve toujours à chercher ce morceau de code:

Date date=Calendar.getInstance().getTime();
System.out.println(date);

java.util.Date date = new java.util.Date();

Il est automatiquement rempli avec l'heure à laquelle il est instancié.

Je trouve que c'est le meilleur moyen:

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

1er Comprendre la java.util.Classe de date

1.1 Comment obtenir la date actuelle

import java.util.Date;

class Demostration{
    public static void main(String[]args){
        Date date = new Date(); // date object
        System.out.println(date); // Try to print the date object
    }
}

1.2 Comment utiliser la méthode getTime ()

import java.util.Date;
public class Main {
    public static void main(String[]args){
        Date date = new Date();
        long timeInMilliSeconds = date.getTime();
        System.out.println(timeInMilliSeconds);
    }
}

Cela renverra le nombre de millisecondes depuis le 1er janvier 1970, 00:00:00 GMT à des fins de comparaison de temps.

1.3 Comment formater l'heure en utilisant la classe SimpleDateFormat

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

class Demostration{
    public static void main(String[]args){
        Date date=new Date();
        DateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd");
        String formattedDate=dateFormat.format(date);
        System.out.println(formattedDate);
    }
}

Essayez également d'utiliser différents modèles de format comme "aaaa-MM-jj hh:mm:ss" et sélectionnez le modèle souhaité. http://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html

2ème Comprendre la java.util.Classe calendrier

2.1 Utilisation de la classe Calendar pour obtenir l'horodatage actuel

import java.util.Calendar;

class Demostration{
    public static void main(String[]args){
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar.getTime());
    }
}

2.2 Essayez d'utiliser setTime et d'autres méthodes set pour définir le calendrier à une date différente.

Source: http://javau91.blogspot.com/

Utilisation:

SimpleDateFormat sdf = new SimpleDateFormat("yyyy:MM:dd::HH:mm:ss");
System.out.println(sdf.format(System.currentTimeMillis()));

L'instruction print affichera l'heure à laquelle elle est appelée et non quand SimpleDateFormat a été créé. Il peut donc être appelé à plusieurs reprises sans créer de nouveaux objets.

Pour java.util.Date, il suffit de créer une nouvelle Date ()

DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date date = new Date();
System.out.println(dateFormat.format(date)); //2016/11/16 12:08:43

Pour java.util.Calendrier, utilise le calendrier.getInstance ()

DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Calendar cal = Calendar.getInstance();
System.out.println(dateFormat.format(cal)); //2016/11/16 12:08:43

Pour java.temps.LocalDateTime, utilise LocalDateTime.maintenant()

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now();
System.out.println(dtf.format(now)); //2016/11/16 12:08:43

Pour java.temps.LocalDate, utilise LocalDate.maintenant()

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate localDate = LocalDate.now();
System.out.println(dtf.format(localDate)); //2016/11/16

Référence: https://www.mkyong.com/java/java-how-to-get-current-date-time-date-and-calender/

Jetez un oeil à la classe Date . Il y a aussi la nouvelle classe Calendar qui est la méthode préférée pour effectuer de nombreuses opérations date / heure (beaucoup de méthodes sur Date ont été obsolètes.)

Si vous voulez juste la date actuelle, alors créez un nouvel objet Date ou appelez Calendar.getInstance();.

Comme mentionné, la date de base() peut faire ce dont vous avez besoin pour obtenir l'heure actuelle. Dans mon expérience récente de travail intensif avec les dates Java, il y a beaucoup de bizarreries avec les classes intégrées (ainsi que la dépréciation de nombreuses méthodes de classe Date). Une bizarrerie qui m'a marqué était que les mois sont basés sur un indice 0, ce qui, d'un point de vue technique, a du sens, mais en termes réels, peut être très déroutant.

Si vous n'êtes concerné que par la date actuelle qui devrait cela suffit-cependant, si vous avez l'intention de faire beaucoup de manipulations/calculs avec des dates, il pourrait être très bénéfique d'utiliser une bibliothèque tierce (il en existe tellement car de nombreux développeurs Java n'ont pas été satisfaits de la fonctionnalité intégrée).

Je soutiens la recommandation de Stephen C car j'ai trouvé que Joda-time était très utile pour simplifier mon travail avec les dates, il est également très bien documenté et vous pouvez trouver de nombreux exemples utiles sur le Web. J'ai même fini par écrire un wrapper statique classe (comme DateUtils) que j'utilise pour consolider et simplifier toutes mes manipulations de date courantes.

import java.util.*;
import java.text.*;

public class DateDemo {
   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
      System.out.println("Current Date: " + ft.format(dNow));
   }
}

Vous pouvez utiliser la date pour les données actuelles fet. donc, en utilisant SimpleDateFormat obtenir le format

 System.out.println( new SimpleDateFormat("yyyy:MM:dd - hh:mm:ss a").format(Calendar.getInstance().getTime()) );
    //2018:02:10 - 05:04:20 PM

Date / heure avec AM / PM

Une nouvelle API Data-Time est introduite avec l'aube de Java 8. Cela est dû aux problèmes suivants qui ont été causés dans l'ancienne API data-time.

Difficile à gérer fuseau horaire: besoin d'écrire beaucoup de code à traiter fuseau.

Non Thread Safe : java.util.La Date n'est pas thread-safe.

Alors jetez un oeil autour de Java 8

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;


public class DataTimeChecker {

    public static void main(String args[]) {
        DataTimeChecker dateTimeChecker = new DataTimeChecker();
        dateTimeChecker.DateTime();
    }

    public void DateTime() {
        // Get the current date and time
        LocalDateTime currentTime = LocalDateTime.now();
        System.out.println("Current DateTime: " + currentTime);

        LocalDate date1 = currentTime.toLocalDate();
        System.out.println("Date : " + date1);

        Month month = currentTime.getMonth();
        int day = currentTime.getDayOfMonth();
        int seconds = currentTime.getSecond();

        System.out.println("Month : " + month);
        System.out.println("Day : " + day);
        System.out.println("Seconds : " + seconds);

        LocalDateTime date2 = currentTime.withDayOfMonth(17).withYear(2018);
        System.out.println("Date : " + date2);

        //Prints 17 May 2018
        LocalDate date3 = LocalDate.of(2018, Month.MAY, 17);
        System.out.println("Date : " + date3);

        //Prints 04 hour 45 minutes
        LocalTime date4 = LocalTime.of(4, 45);
        System.out.println("Date : " + date4);

        // Convert to a String 
        LocalTime date5 = LocalTime.parse("20:15:30");
        System.out.println("Date : " + date5);
    }
}

Sortie du codage ci-dessus:

Current DateTime: 2018-05-17T04:40:34.603
Date : 2018-05-17
Month : MAY
Day : 17
Seconds : 34
Date : 2018-05-17T04:40:34.603
Date : 2018-05-17
Date : 04:45
Date : 20:15:30

Vous pouvez utiliser l'objet et le format Date par vous-même. Il est difficile de formater et besoin de plus de codes, par exemple,

Date dateInstance = new Date();
int year = dateInstance.getYear()+1900;//Returns:the year represented by this date, minus 1900.
int date = dateInstance.getDate();
int month = dateInstance.getMonth();
int day = dateInstance.getDay();
int hours = dateInstance.getHours();
int min = dateInstance.getMinutes();
int sec = dateInstance.getSeconds();

String dayOfWeek = "";
switch(day){
    case 0:
        dayOfWeek = "Sunday";
        break;
    case 1:
        dayOfWeek = "Monday";
        break;
    case 2:
        dayOfWeek = "Tuesday";
        break;
    case 3:
        dayOfWeek = "Wednesday";
        break;
    case 4:
        dayOfWeek = "Thursday";
        break;
    case 5:
        dayOfWeek = "Friday";
        break;
    case 6:
        dayOfWeek = "Saturday";
        break;
}
System.out.println("Date: " + year +"-"+ month + "-" + date + " "+ dayOfWeek);
System.out.println("Time: " + hours +":"+ min + ":" + sec);

Sortie:

Date: 2017-6-23 Sunday
Time: 14:6:20

Comme vous pouvez le voir, c'est la pire façon de le faire et selon la documentation oracle, il est obsolète.

Doc Oracle:

La date de classe représente un instant spécifique dans le temps, avec la milliseconde précision.

Avant JDK 1.1, la date de classe avait deux fonctions supplémentaires. Il permis l'interprétation des dates de l'année, mois, jour, heure, minute, et deuxièmes valeurs. Il a également permis le formatage et l'analyse de la date chaîne. Malheureusement, l'API pour ces fonctions n'était pas prête à l'internationalisation. À partir de JDK 1.1, la classe Calendar doit être utilisé pour convertir entre les champs dates et heure et la classe DateFormat doit être utilisé pour formater et analyser les chaînes de date. Le correspondant les méthodes dans Date sont obsolètes.

Donc alternativement, vous pouvez utiliser Calendar classe,

Calendar.YEAR;
//and lot more

Pour obtenir l'heure actuelle, vous pouvez utiliser:

Calendar rightNow = Calendar.getInstance();

Doc:

Comme les autres classes sensibles aux paramètres régionaux, Calendar fournit une méthode de classe, getInstance, pour obtenir un objet généralement utile de ce type. La méthode Calendar getInstance renvoie un objet Calendar dont le calendrier les champs ont été initialisés avec la date et l'heure actuelles

Ci-dessous le code pour obtenir uniquement la date

Date rightNow = Calendar.getInstance().getTime();
System.out.println(rightNow);

Aussi, Calendar classe ont Les sous-classes. GregorianCalendar est l'un d'entre eux et une sous-classe concrète de Calendar et fournit le système de calendrier standard utilisé par la plupart du monde.

Exemple en utilisant GregorianCalendar:

Calendar cal = new GregorianCalendar();
int hours = cal.get(Calendar.HOUR);
int minute = cal.get(Calendar.MINUTE);
int second = cal.get(Calendar.SECOND);
int ap = cal.get(Calendar.AM_PM);

String amVSpm;
if(ap == 0){
    amVSpm = "AM";
}else{
    amVSpm = "PM";
}

String timer = hours + "-" + minute + "-" + second + " " +amVSpm;
System.out.println(timer);

, Vous pouvez utiliser SimpleDateFormat, moyen simple et rapide de format de date:

String pattern = "yyyy-MM-dd";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);

String date = simpleDateFormat.format(new Date());
System.out.println(date);

Lire ce Jakob Jenkov tutoriel: Java SimpleDateFormat.

Comme d'autres l'ont mentionné, lorsque nous avons besoin de faire de la manipulation à partir de dates, nous n'avions pas de moyen simple et le meilleur ou nous ne pouvions pas nous satisfaire construit dans les classes, les interfaces de programmation.

Par exemple, Lorsque nous devons obtenir différents entre deux dates, lorsque nous devons comparer deux dates(il existe également une méthode intégrée pour cela) et bien d'autres. Nous avons dû utiliser des bibliothèques tierces. L'un des bons et populaires est Joda Time.

Lire Aussi:

• Comment obtenir correctement la date et l'heure actuelles dans Joda-Time?
• JodaTime - comment obtenir l'heure actuelle dans UTC
• Exemples de JodaTime.
• Télécharger Joda

. La chose la plus heureuse est maintenant(en java 8), personne n'a besoin de télécharger et d'utiliser des bibliothèques pour quelque raison que ce soit. Un exemple simple pour obtenir la date et l'heure actuelles dans Java 8,

LocalTime localTime = LocalTime.now();
System.out.println(localTime);

//with time zone
LocalTime localTimeWtZone = LocalTime.now(ZoneId.of("GMT+02:30"));
System.out.println(localTimeWtZone);

L'Un des bon billet de blog à lire sur Java 8 date.

Et gardez à l'esprit pour en savoir plus sur la date et l'heure Java car il y a beaucoup plus de moyens et/ou de moyens utiles que vous pouvez get/utilisation.

• Oracle tutoriels pour la date et de l'heure.
• Oracle tutoriels pour formateur.
• Leçon: Calendrier standard.

MODIFIER:

Selon @BasilBourque commentaire, le gênants vieille date-heure classes telles que java.util.Date, java.util.Calendar, et java.text.SimpleTextFormat sont maintenant héritage, supplantée par l'java.time les classes.

Je vais aller de l'avant et jeter cette réponse parce que c'est tout ce dont j'avais besoin quand j'avais la même question:

Date currentDate = new Date(System.currentTimeMillis());

currentDate est maintenant votre date actuelle dans une Java Date objet.