Comment obtenir l'horodatage actuel en Java

En Java, obtenir l'horodatage actuel est simple. Nous allons apprendre à acquérir l'horodatage à l'aide des classes Date et Timestamp de cette leçon. Cet article fournit des exemples Java pour obtenir la date, l'heure ou l'horodatage actuel. De plus, Java 8 a été inclus.

L'horodatage représente la date et l'heure d'une occurrence. Il peut s'agir de la date et de l'heure auxquelles une entrée ou une sortie particulière a été effectuée ou de tout autre événement informatique interne, tel que l'ajout de données spécifiques dans une base de données dans des ordinateurs. L'horodatage de Now est l'horodatage actuel. Si un événement se produit maintenant et que l'horodatage est enregistré, l'horodatage sera celui d'hier demain.

Un horodatage local, un horodatage GMT et un horodatage UTC sont tous disponibles. L'horodatage local est la date et l'heure utilisées à des fins juridiques, commerciales et sociales de votre pays. La référence pour les horodatages GMT et UTC est la même. Un fuseau horaire est un décalage de pays qui peut être appliqué à UTC pour obtenir votre heure locale. Un fuseau horaire de +03:30 signifie que l'UTC a été prolongé de 3 heures et 30 minutes.

L'année, le mois et le jour du mois sont tous inclus dans la partie date de l'horodatage. Le composant temporel de l'horodatage comprend au moins l'heure, les minutes et les secondes. Les millisecondes et le fuseau horaire peuvent également être inclus (décalage). Notez que 1 ms =1/1000 s. Par conséquent, l'ordinateur doit fournir l'horodatage. Par conséquent, l'horloge système doit être précise. java.time est la classe. Dans Java d'aujourd'hui, instant devrait être utilisé pour obtenir l'horodatage.

java.time.Instant

Java a une classe appelée java.time. L'instant a été explicitement créé pour les horodatages. Il existe deux méthodes requises dans la classe Instant :now () et toString (). L'objet d'horodatage est renvoyé par « Maintenant ». Le format de chaîne de l'horodatage est produit par toString(). Le programme suivant illustre leur application :

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant timestamp_object = Instant.now();

String timestamp_string = timestamp_object.toString();

System.out.println(timestamp_string);

}

}

Le programme démarre avec la classe Instant du package java.time en cours d'importation. Ensuite, il y a la définition de la classe principale (implémentation). La première instruction de la méthode main() appelle la méthode now() de la classe Instant. Now() est une méthode statique, ce qui signifie qu'elle n'a pas besoin de l'objet instancié pour fonctionner. Il renvoie l'objet d'horodatage de sa classe Instant en utilisant le nom de la classe Instant. La méthode toString() de l'objet timestamp Instant renvoie la chaîne lisible de l'objet timestamp au format ISO-8601. L'ordinateur génère la sortie suivante au moment de l'exécution :

2022-05-22T11:53:15.271438Z

Cela nécessite plus d'explications. Les quatre premiers chiffres représentent l'année de l'événement. Il est séparé des deux chiffres suivants, le mois de l'événement, par un trait d'union. Ce dernier est séparé des deux chiffres suivants, le jour du mois de l'événement, par un trait d'union. Un horodatage comprend deux parties :la date et l'heure. Le « T » sépare les sections de date et d'heure. La section horaire commence par deux chiffres (horloge 24 heures), l'heure de l'événement. Il est séparé des deux chiffres suivants, qui représentent les minutes de l'événement, par deux-points.

Il est suivi de deux points, qui le séparent des deux chiffres suivants, représentant les secondes de l'événement. Il y a aussi le point et les microsecondes à considérer. L'horodatage n'a pas de décalage s'il s'agit de Z. Notez que toString() est une méthode dynamique. Pour fonctionner, il nécessite un objet Instant initialisé. Il vous donne également une chaîne que vous pouvez enregistrer (dans une base de données).

Époque de Java

En Java, le temps est calculé à l'aide de l'époque UNIX. 1970-01-01T00:00:00Z est l'époque UNIX.

Le nombre de secondes depuis l'époque Java

Depuis Java Epoch, l'application suivante calcule le nombre de secondes :

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant timestampObj = Instant.now();

long codeSecs = timestampObj.getEpochSecond();

System.out.println(codeSecs);

}

}

La fonction getEpochSecond() de l'objet Instant est utilisée. Il renvoie un entier long.

instant minusSeconds(longs secondsToSubtract)

Avec plusieurs secondes soustraites, la date-heure actuelle peut être renvoyée. Il produira une date-heure avant maintenant. Il est démontré dans le programme suivant :

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant instantObject = Instant.now();

Instant codeObject = instantObject.minusSeconds(1000000000);

String codeStr = codeObject.toString();

System.out.println(codeStr);

}

}

Avant de soustraire le nombre de secondes, vous devez collecter l'objet d'horodatage actuel. Voici la principale méthode utilisée :

minusSeconds(long secondsToSubtract)

Cela ne fonctionne qu'avec des objets immédiats, pas avec des classes instantanées (nom).

plusSeconds (long secondsToAdd)

Avec plusieurs secondes ajoutées, la date-heure actuelle peut être renvoyée. Après cela, vous aurez datetime. Il est démontré dans le programme suivant :

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstObject = Instant.now();

Instant codeSbObj = codeInstObject.plusSeconds(1000000);

String codeStr = codeSbObj.toString();

System.out.println(codeStr);

}

}

Vous devez obtenir l'objet d'horodatage actuel avant que le nombre de secondes ne soit ajouté. Voici la principale méthode utilisée :

plusSeconds(long secondsToAdd)

Cela ne fonctionne qu'avec des objets immédiats, pas avec des classes instantanées (nom).

Propriétés statiques de la classe instantanée

EPOCH, MAX et MIN sont les attributs statiques (champs) de la classe Instant. L'objet instancié n'est pas obligé d'accéder à une propriété statique. Cela fonctionne avec le nom de la classe. EPOCH est,

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstObject = Instant.EPOCH;

String codeStr = codeInstObject.toString();

System.out.println(codeStr);

}

}

Comme prévu, la sortie résultante est 1970-01-01T00:00:00Z

MAX donne l'instantané maximal pris en charge. La valeur de MAX est sortie sous forme de chaîne à l'aide du programme suivant :

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstantObject = Instant.MAX;

String codeStr = codeInstantObject.toString();

System.out.println(codeStr);

}

}

MIN renvoie le moindre instantané pris en charge. La valeur de MIN est sortie sous forme de chaîne à l'aide du programme suivant :

import java.time.Instant;

public class CodeInstant {

public static void main(String[] args) {

Instant codeInstantObject = Instant.MIN;

String codeStr = codeInstantObject.toString();

System.out.println(codeStr);

}

}

Utilisation de la classe d'horodatage de Java pour obtenir l'horodatage actuel

La classe Timestamp en Java est utilisée pour obtenir l'horodatage actuel. Nous passons le temps en millisecondes car cette classe n'a pas de constructeur par défaut. Nous utilisons la méthode currentTimeMillis() de la classe System pour obtenir l'heure. Prenons l'exemple suivant.

import java.sql.Timestamp;

public class CodeTimestamp {

    public static void main(String[] args) {

        Long date_time = System.currentTimeMillis();
        Timestamp codeTimestamp = new Timestamp(ate_time);
        System.out.println("The Current Time Stamp: "+codeTimestamp);
    }
}

À l'aide de la classe Date de Java, obtenez l'horodatage actuel

Nous pouvons utiliser la classe Date du package util pour acquérir l'horodatage actuel. La classe SimpleDateFormat est utilisée pour formater l'horodatage au format aaaa.MM.jj. Prenons l'exemple suivant.

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

public class CodeSimpleDateFormat{

    public static void main(String[] args) {

        SimpleDateFormat codeDate = new SimpleDateFormat("yyyy.MM.dd.HH:mm:ss");
        String codeTimeStamp = codeDate.format(new Date());
        System.out.println("The Current Time Stamp is: "+codeTimeStamp);
    }
}

Java utilise la classe ZonedDateTime pour obtenir l'horodatage actuel

La classe ZonedDateTime du package Java datetime génère un horodatage avec des informations de zone. Nous obtenons la zone par défaut du système à l'aide de la fonction systemDefault() de ZoneId, et nous obtenons l'horodatage actuel avec le zoneId fourni à l'aide de la méthode now(). Après avoir obtenu l'horodatage actuel, nous utilisons la fonction ofPattern() de la classe DateTimeFormatter pour obtenir l'horodatage dans un format particulier. Prenons l'exemple suivant.

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class CodeZonedDateTime{

    public static void main(String[] args) {

        ZoneId codeZid = ZoneId.systemDefault();
        ZonedDateTime dateTime = ZonedDateTime.now(codeZid);
        System.out.println("The Current Time Stamp is: "+dateTime);

        // formatting into a specific format
        DateTimeFormatter codeFormatter = DateTimeFormatter.ofPattern( "uuuu.MM.dd.HH:mm:ss" );
        String codeTimeStamp = datetime.format(codeFormatter);
        System.out.println("The Current Time Stamp is: "+codeTimeStamp);
    }
}

L'utilisation par Java de la classe LocalDateTime pour obtenir l'horodatage actuel

À l'aide de Java 8, vous pouvez acquérir l'horodatage actuel à l'aide de la classe LocalDateTime. Prenons l'exemple suivant.

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

public class CodeLocalDateTime{

    public static void main(String[] args) {

        LocalDateTime codeDateTime = LocalDateTime.now();
        System.out.println("The Current Time Stamp's Default Format is: "+codeDateTime);
        String codeTimeStamp = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(codeDateTime);
        System.out.println("The Current Time Stamp is: "+codeTimeStamp);
    }
}

L'utilisation par Java de la classe instantanée pour obtenir l'horodatage actuel

L'horodatage actuel peut être obtenu à l'aide de la classe Instant. Pour obtenir l'horodatage actuel en instants, nous utilisons la fonction now() de la classe Instant.

import java.time.Instant;

public class CodeInstant{

    public static void main(String[] args) {
        Instant codeTimeStamp = Instant.now();
        System.out.println(" Your Current Default Format Time Stamp is: "+codeTimeStamp);
    }
}

Utilisation de la classe d'horodatage de Java pour obtenir l'horodatage actuel

Les classes Timestamp et Instant fournissent un autre moyen d'obtenir l'horodatage actuel en Java. Prenons l'exemple suivant.

import java.sql.Timestamp;
import java.time.Instant;

public class CodeTimestamp {

    public static void main(String[] args) {

        long codeTime = System.currentTimeMillis();
        Timestamp codeTimestamp = new Timestamp(codeTime);
        Instant codeInstant = codeTimestamp.toInstant();
        System.out.println("The Current codeInstant Time Stamp is: "+codeInstant);
    }
}

L'utilisation par Java de la méthode toInstant() pour obtenir l'horodatage actuel

De plus, nous pouvons engager la méthode toInstant() de la classe Date pour acquérir l'horodatage actuel si nous avons un objet date reflétant l'horodatage.

import java.time.Instant;
import java.util.Date;

public class CodeToInstant {

    public static void main(String[] args) {

        Date codeDate = new Date();
        Instant codeInstant = codeDate.toInstant();
        System.out.println("The Current codeInstant Time Stamp is: "+codeInstant);
    }
}

Exemple :Java Obtenir l'horodatage

import java.util.Date;
import java.sql.Timestamp;
 
public class CodeFetchTimeStamp
{
    public static void main( String[] args )
    {
 
 Date newDate= new Date();
 
 long timeNow = newDate.getTime();
     System.out.println("The Time now in Milliseconds: " + timeNow);
 
 Timestamp timestamp = new Timestamp(time);
 System.out.println("The Current Time Stamp is: " + timestamp);
    }
}

La fonction getTime() est utilisée dans l'exemple suivant pour obtenir l'heure actuelle en millisecondes. L'horodatage sera ensuite converti à l'heure correcte. L'exemple suivant est multiligne. Cependant, si vous ne voulez que l'horodatage actuel, utilisez le code d'une ligne ci-dessus.

Exemple :obtenir uniquement la date en Java

Pour trouver uniquement la date et l'heure, utilisez SimpleDateFormat avec la classe Calendar.

import java.util.Calendar;
import java.text.SimpleDateFormat;
 
public class CodeFetchTimeStamp
{
    public static void main( String[] args )
    {
         Calendar newCalendar = Calendar.getInstance();
 
         SimpleDateFormat sDateFormat = new SimpleDateFormat("MM/dd/yyyy");
         System.out.println(sDateFormat .format(newCalendar .getTime()));
    }
}

Exemple :récupérer l'heure actuelle en Java

Vous pouvez également utiliser SimpleDateFormat avec la classe Calendar pour trouver uniquement l'heure.

import java.util.Calendar;
import java.text.SimpleDateFormat;
 
public class CodeFetchTimeStamp
{
    public static void main( String[] args )
    {
         Calendar codeCalendar = Calendar.getInstance();
 
         SimpleDateFormat sDateFormat = new SimpleDateFormat("HH:mm:ss");
         System.out.println(sDateFormat .format(codeCalendar.getTime()));
    }
}

Exemple :Illustrer l'utilisation de l'horodatage

// 2022-05-22 16:48:05.591
Timestamp new_timestamp = new Timestamp(System.currentTimeMillis());
System.out.println(new_timestamp)

  // 2022-05-22 16:48:05.591
  Date newDate = new Date();
Timestamp new_timestamp_two = new Timestamp(newDate.getTime());
System.out.println(new_timestamp_two)

  // convertion of an Instant to Timestamp
  Timestamp new_timestamp_three = Timestamp.from(Instant.now())
  System.out.println(new_timestamp_three)

  // convertion of a ZonedDateTime to Instant to Timestamp
  Timestamp new_timestamp_four = Timestamp.from(ZonedDateTime.now().toInstant()));
System.out.println(new_timestamp_four)

  // conversion of a Timestamp to Instant
  Instant instant = new_timestamp_four.toInstant();

Exemple :horodatages Java

Le logiciel suivant utilise java.sql.Timestamp pour acquérir l'horodatage actuel et SimpleDateFormat pour formater l'affichage.

package com.codeunderscored;

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

public class CodeTimeStamp {

    // 2021.05.22.16.34.26
    private static final SimpleDateFormat simpleDateFormatOne = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss");
System.out.println(simpleDateFormatOne)

    // 2021-05-22T16:44:39.083+08:00
    private static final SimpleDateFormat simpleDateFormatTwo = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");

    // 2021-05-22 16:48:05
    private static final SimpleDateFormat simpleDateFormatThree = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) {

        // approach one
        Timestamp codeTimestamp = new Timestamp(System.currentTimeMillis());
        System.out.println(codeTimestamp);                      // 2021-05-22 16:34:26.666

        // approach two - via Date
        Date newDate = new Date();
        System.out.println(new Timestamp(newDate.getTime()));  // 2022-05-22 16:34:26.666
                                                            // The milliseconds count since January 1, 1970, 00:00:00 GMT
        System.out.println(codeTimestamp.getTime());            // 1616574866666

        System.out.println(simpleDateFormatOne.format(timestamp));         // 2022.05.22.16.34.26

        System.out.println(simpleDateFormatTwo.format(timestamp));         // 2022-05-22T16:48:05.591+08:00

        System.out.println(simpleDateFormatThree.format(timestamp));         // 2022-05-22 16:48:05

    }
}

Exemple :Instant vers ou depuis le convertisseur d'horodatage

Cet exemple montre comment utiliser la nouvelle classe Java 8 java.time. Vers et depuis l'ancien java.sql.Timestamp est instantané.

 // conversion of the Instant to an equivalent Timestamp
  Timestamp codeTimestamp = Timestamp.from(Instant.now())

  // converting a Timestamp to a corresponding Instant
  Instant instant = codeTimestamp.toInstant();

package com.codeunderscored;

import java.sql.Timestamp;
import java.time.Instant;

public class CodeInstant {

  public static void main(String[] args) {

      Timestamp codeTimestamp = new Timestamp(System.currentTimeMillis());
      System.out.println(codeTimestamp);                  // 2022-05-22 17:12:03.311
      System.out.println(codeTimestamp.getTime());        // 1616577123311

      // Converting a Timestamp to an Instant
      Instant newInstant = codeTimestamp.toInstant();
      System.out.println(newInstant);                    // 2022-05-22T09:12:03.311Z
      System.out.println(newInstant.toEpochMilli());     // 1616577123311

      // Conversion of an Instant to a corresponding Timestamp
      Timestamp timestampFromInstant = Timestamp.from(instant);
      System.out.println(timestampFromInstant.getTime());    // 1616577123311
  }
}

Exemple :Créer un tableau avec un horodatage

Dans la programmation JDBC, l'horodatage est encore largement utilisé. Considérez les conversions suivantes :

  // Java 8, java.time.*

  // converting a LocalDateTime to respective Timestamp
  preparedStatement.setTimestamp(1, Timestamp.valueOf(LocalDateTime.now()));

  // converting an Instant to a Timestamp
  preparedStatement.setTimestamp(1, Timestamp.from(Instant.now()));

  // Converting a ZonedDateTime to a corresponding Instant then to a  Timestamp
  preparedStatement.setTimestamp(3, Timestamp.from(ZonedDateTime.now().toInstant()));


The subsequent SQL example shows how to insert a Timestamp into a table using JDBC.

package com.codeunderscored;

import java.math.BigDecimal;
import java.sql.*;
import java.time.LocalDateTime;

public class CodeJdbc {

  private static final String sql_query = "INSERT into Code_Employee (name, emp_no, date_created) VALUES (?,?,?)";

  public static void main(String[] args) {

      try (Connection codeConnection = DriverManager.getConnection(
              "jdbc:postgresql://127.0.0.1:5432/code", "code", "Underscored");
           PreparedStatement codePrStatement = codeConnection.prepareStatement(sql_query)) {

          codePrStatement.setString(1, "Joy");
          codePrStatement.setBigDecimal(2, new BigDecimal("098"));
          codePrStatement.setTimestamp(3, Timestamp.valueOf(LocalDateTime.now()));

	// other alternatives for the date_created value
          // codePrStatement.setTimestamp(3, Timestamp.from(ZonedDateTime.now().toInstant()));
          // codePrStatement.setTimestamp(3, Timestamp.from(Instant.now()));

          int codeRow = codePrStatement.executeUpdate();

          // The count of rows affected
          System.out.println(codeRow); //1

      } catch (SQLException e) {
          System.err.format("SQL State: %s\n%s", e.getSQLState(), e.getMessage());
      } catch (Exception e) {
          e.printStackTrace();
      }

  }
}

Exemple :Comment obtenir l'horodatage actuel en Java

import java.sql.Timestamp;
import java.util.Date;

public class CodeTimeStamp
{
    public static void main( String[] args )
    {
         // Creating a Date object
	 Date codeDate= new Date();

         //getTime() returns current time in milliseconds
	 long codeTime = codeDate.getTime();

         // the count milliseconds is passed to constructor of Timestamp class
	 Timestamp codeTimestamp = new Timestamp(time);
	 System.out.println("The Current Time Stamp is: "+codeTimestamp);
    }
}

Les actions que nous avons prises dans l'exemple ci-dessus sont les suivantes :

1) Création d'un objet de classe Date.

2) En utilisant la méthode getTime() de Date, nous avons obtenu l'heure actuelle en millisecondes.

3) Création d'un objet de classe Timtestamp et fourniture des millisecondes obtenues à l'étape 2 au constructeur de la classe lors de la construction de l'objet. Ce dernier crée l'horodatage à partir de la milliseconde fournie.

Conclusion

Cette leçon vous a montré comment récupérer l'horodatage actuel en Java et inclut un exemple de code pour vous aider à comprendre le concept. La classe Timestamp, la classe Date, la classe ZonedDateTime, la classe LocalDateTime et d'autres classes Java peuvent toutes être utilisées pour obtenir l'horodatage actuel.

L'horodatage représente la date et l'heure d'une occurrence. L'horodatage de Now est l'horodatage actuel. La classe Instant du package Java, java.time.*, doit être utilisée pour le travail d'horodatage. Notez également que la classe timestamp a deux méthodes importantes :now() et toString().