Java >> Tutoriel Java >  >> Tag >> String

Comment formater une date en chaîne en Java

La modification du format de date d'une date ou d'une chaîne donnée est une tâche de programmation Java typique. Par exemple, supposons que vous ayez "2022-05-22 12:00:00" et que vous souhaitiez le convertir en "2022-05-22", ou convertir de jj-MM-AA en MM-jj-AA, ou tout autre format que vous aimez, tant qu'il s'agit d'un format de date valide tel que défini par Java. Comment allez-vous accomplir cela ? Ce n'est pas si difficile, après tout. C'est une procédure simple en deux étapes.

Il serait utile que vous analysiez d'abord String pour construire une date équivalente dans le format existant, puis que vous reconvertissiez la date en String dans le nouveau format. L'approche est similaire à Java 8 et versions antérieures, à l'exception des changements d'API et de classe.

La fonction format() du package java.text.DateFormat est utilisée pour convertir Date en String en Java.

La classe java.text.SimpleDateFormat est utilisée pour analyser et formater les dates selon un modèle de formatage personnalisé. Le Java SimpleDateFormat utilise généralement une chaîne Java comme source lors du traitement des dates. Lors du formatage des dates, SimpleDateFormat convertit un objet Date en String, mais il peut également convertir un objet Date en StringBuffer. La classe SimpleDateFormat est responsable du formatage des dates dans ce texte.

Création SimpleDateFormat

Créez un objet SimpleDateFormat comme suit :

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

Le modèle d'analyse et de formatage de la date est spécifié par le paramètre pattern fourni au constructeur SimpleDateFormat. Une chaîne Java standard est utilisée comme modèle.

Formatage des dates

Une fois que vous avez généré une instance SimpleDateFormat, vous pouvez utiliser sa fonction format() pour formater les dates. Considérez le scénario suivant :

String datePattern = "yyyy-MM-dd";
SimpleDateFormat simpleFormat = new SimpleDateFormat(datePattern);

String newDate = simpleFormat.format(new Date());
System.out.println(newDate);

La fonction format() prend une instance de java.util.Date comme argument. Voici la sortie de l'exemple SimpleDateFormat :

2022-05-22

Notez comment la chaîne de date formatée commence par l'année, le mois et le jour. Le modèle de date fourni au constructeur SimpleDateFormat détermine l'ordre des champs de date. Comme indiqué précédemment, ce format est abordé plus en détail dans cette leçon Java SimpleDateFormat.

StringBuffer avec format de date

Au lieu de renvoyer une chaîne individuelle avec la date préparée, la classe Java SimpleDateFormat peut formater un objet Date dans un StringBuffer. Elle est accomplie via la méthode format() de la classe SimpleDateFormat, qui prend les instances Date, StringBuffer et FieldPosition comme entrées. Voici un exemple d'utilisation de Java SimpleDateFormat pour formater une date dans un StringBuffer :

StringBuffer strBuffer = new StringBuffer();
Date dateNow = new Date();

SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ssZ");
simpleFormat.format(dateNow, strBuffer, new FieldPosition(0));

On ne sait pas comment l'instance FieldPosition est utilisée. Quelle que soit la valeur int fournie au constructeur FieldPosition, la méthode format() ajoute la chaîne formatée à la fin du StringBuffer.

Analyse des dates

La méthode parse() de la classe SimpleDateFormat convertit une chaîne en une instance java.util.Date. Considérez le scénario suivant :

String datePattern = "yyyy-MM-dd";
SimpleDateFormat simpleFormat = new SimpleDateFormat(datePattern);

Date newDate = simpleFormat.parse("2022-05-22");

Une fois ce code exécuté, la variable de date pointe vers une instance Date reflétant le 22 mai 2022.

Création d'un SimpleDateFormat spécifique aux paramètres régionaux

Une instance SimpleDateFormat est créée pour un Java Locale spécifié. Les dates seront formatées en fonction des paramètres régionaux lorsque cela sera fait. Un modèle de formatage qui inclut le nom du jour de la semaine, par exemple, écrira le jour de la semaine dans la langue des paramètres régionaux choisis. Considérez le scénario suivant :

String newPattern = "EEEEE dd MMMMM yyyy HH:mm:ss.SSSZ";
SimpleDateFormat sdFormat =
        new SimpleDateFormat(newPattern, new Locale("da", "DK"));

String dateNow = sdFormat.format(new Date());
System.out.println(dateNow);

Les caractères autres que ceux-ci seront insérés dans le modèle en tant que texte normal et donc dans les dates formatées. Certains caractères sont utilisés dans plusieurs combinaisons. Par exemple, vous pouvez écrire aa pour une version à deux caractères de l'année (par exemple, 22) ou aaaa pour une version à quatre caractères de l'année (par exemple, 2022). Voir le JavaDoc pour la classe SimpleDateFormat pour plus d'informations sur les modèles acceptables.

Exemples de motifs

Voici quelques exemples de modèles de date Java SimpleDateFormat :

dd-MM-yy 	22-05-22
dd-MM-yyyy 	22-05-2022
MM-dd-yyyy 	05-22-2022
yyyy-MM-dd 	2022-05-31
yyyy-MM-dd HH:mm:ss 	2022-05-22 23:59:59
yyyy-MM-dd HH:mm:ss.SSS 	2022-05-22 23:59:59.999
yyyy-MM-dd HH:mm:ss.SSSZ 	2022-05-22 23:59:59.999+0100
EEEEE MMMMM yyyy HH:mm:ss.SSSZ 	Sunday May 2022 12:45:42.720+0100

DateFormatSymbols

Vous pouvez modifier les symboles de date utilisés dans la sortie formatée pour un certain paramètre régional. Un java.text est utilisé pour accomplir cela. Instance de DateFormatSymbols. Considérez le scénario suivant :

Locale newLocale = new Locale("en", "UK");
DateFormatSymbols codeDateFormatSymbols = new DateFormatSymbols(newLocale);
codeDateFormatSymbols.setWeekdays(new String[]{
        "null",
        "Sunday",
        "Monday",
        "Tuesday",
        "Wednesday",
        "Thursday",
        "Friday",
        "Saturday",
});

String newPattern = "EEEEE MMMMM yyyy";
SimpleDateFormat simpleFormat =
        new SimpleDateFormat(newPattern, dateFormatSymbols);

String newDate = simpleFormat.format(new Date());
System.out.println(newDate);

Deuxièmement, un nouvel ensemble de noms de jours de la semaine a été établi. Vous devez noter que la chaîne initiale, "unused", n'est jamais utilisée. Pour être indexables par Calendar.SUNDAY, Calendar.MONDAY et d'autres constantes, les indices de ce tableau doivent commencer par un. Calendar.SUNDAY vaut 1, Calendar.MONDAY vaut 2, etc. Troisièmement, à l'aide de DateFormatSymbols, un SimpleDateFormat est construit et la date est formatée. Voici un exemple de ce à quoi pourrait ressembler la sortie :

Sunday, May 2022

Prenez note de la façon dont le nom personnalisé du jour de la semaine est utilisé. Sur l'instance DateFormatSymbols, vous pouvez ajouter des symboles de formatage de date supplémentaires. Voici les procédures d'ajout de symboles supplémentaires :

dateFormatSymbols.setWeekdays();
dateFormatSymbols.setAmPmStrings();
dateFormatSymbols.setEras();
dateFormatSymbols.setShortWeekdays();
dateFormatSymbols.setZoneStrings();
dateFormatSymbols.setLocalPatternChars();
dateFormatSymbols.setMonths();
dateFormatSymbols.setShortMonths();

Paramètre de fuseau horaire de SimpleDateFormat

Jusqu'à présent, tous les exemples de cette leçon ont utilisé le fuseau horaire par défaut du système. Si vous souhaitez formater une date, SimpleDateFormat supposera que vous souhaitez la formater en fonction du fuseau horaire du système. Ceci, cependant, n'est pas toujours le cas.

La méthode setTimeZone() d'un SimpleDateFormat modifie le fuseau horaire. La fonction setTimeZone() prend en argument une instance Java TimeZone (java.util.TimeZone). Voici un exemple de modification du fuseau horaire d'une instance Java SimpleDateFormat :

SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ssZ");

simpleFormat.setTimeZone(TimeZone.getTimeZone("Europe/Paris"));

Le SimpleDateFormat modifiera sa mise en forme une fois le fuseau horaire défini. Voici un exemple de modification du fuseau horaire en deux fuseaux horaires distincts tout en formatant la même date :

Date dateNow = new Date();

SimpleDateFormat sdFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ssZ");

sdFormat.setTimeZone(TimeZone.getTimeZone("Europe/London"));
System.out.println(sdFormat .format(dateNow));

sdFormat.setTimeZone(TimeZone.getTimeZone("Europe/Paris"));
System.out.println(sdFormat .format(dateNow));

Méthode format() de DateFormat

Pour convertir une date en chaîne, utilisez la fonction format() de la classe DateFormat. DateFormat est un type générique. SimpleDateFormat est une classe enfant DateFormat. C'est ainsi que la classe DateFormat est implémentée. La signature de la méthode format() est la suivante :

String format(Date d)  

Exemple de date Java en chaîne

Regardons un code Java simple pour convertir une date en chaîne.

Date newDate = Calendar.getInstance().getTime();  
DateFormat codeDateFormat = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");  
String stringDate = codeDateFormat.format(newDate);  



import java.text.DateFormat;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
import java.util.Calendar;  
public class DateToStringExample1 {  
  public static void main(String args[]){  
    Date date = Calendar.getInstance().getTime();  
    DateFormat dateFormat = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");  
    String strDate = dateFormat.format(date);  
    System.out.println("Converted String: " + strDate);  

  }  
}  

Examinons l'exemple complet de conversion de date et d'heure en chaîne en Java à l'aide de la fonction format() de la classe java.text.SimpleDateFormat.

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

    public class CodeDateToString {  

    public static void main(String[] args) {  
        Date newDate = new Date();  
        SimpleDateFormat simpleFormatter = new SimpleDateFormat("MM/dd/yyyy");  
        String stringDate = simpleFormatter.format(newDate);  
        System.out.println("The Date Format with is: MM/dd/yyyy : "+stringDate);  
      
        simpleFormatter = new SimpleDateFormat("dd-M-yyyy hh:mm:ss");  
        stringDate = simpleFormatter.format(newDate);  
        System.out.println("The Date Format with dd-M-yyyy hh:mm:ss  is: "+stringDate);  
      
        simpleFormatter = new SimpleDateFormat("dd MMMM yyyy");  
        stringDate = simpleFormatter.format(newDate);  
        System.out.println("The Date Format with dd MMMM yyyy is: "+stringDate);  
      
        simpleFormatter = new SimpleDateFormat("dd MMMM yyyy zzzz");  
        stringDate = simpleFormatter.format(newDate);  
        System.out.println("The Date Format with dd MMMM yyyy zzzz is: "+stringDate);  
      
        simpleFormatter = new SimpleDateFormat("E, dd MMM yyyy HH:mm:ss z");  
        stringDate = simpleFormatter.format(newDate);  
        System.out.println("The Date Format with E, dd MMM yyyy HH:mm:ss z  is: "+stringDate);  
    }  
    }  

conversion de java.util.Date en chaîne

Bien que nous ne devrions pas utiliser java.util.Date lorsque nous traitons avec Java 8, il y a des situations où nous n'avons pas le choix (par exemple, lorsque l'objet Date provient d'une bibliothèque que nous ne contrôlons pas). Dans de telles circonstances, nous avons de nombreuses options pour convertir java.util.Date en String.

Préparation de l'objet Date  :Commençons par déclarer une représentation String anticipée de notre date et un modèle de format de date :

private static final String EXPECTED_STRING_DATE = "May 22, 2022 12:00 PM";
private static final String DATE_FORMAT = "MMM d, yyyy HH:mm a";

Nous avons maintenant besoin d'un objet Date réel à convertir. Pour ce faire, nous utiliserons une instance de Calendar :

TimeZone.setDefault(TimeZone.getTimeZone("CET"));
Calendar calendar = Calendar.getInstance();
calendar.set(2022, Calendar.MAY, 22, 12, 0);
Date date = calendar.getTime();

Pour éviter les complications lors de l'utilisation ultérieure de la nouvelle API, nous avons défini le fuseau horaire par défaut sur CET. L'objet Date n'a pas de fuseau horaire, mais sa méthode toString() utilise le fuseau horaire par défaut actuel. Cette instance de Date est utilisée dans tous les exemples qui suivent.

Utilisation de la classe abstraite DateFormat

SimpleDateFormat est une sous-classe de la classe abstraite DateFormat, comme nous pouvons le voir. Cette classe contient des méthodes pour formater les dates et les heures. Nous allons l'utiliser pour obtenir le même résultat qu'avant :

String formattedDate = DateFormat
  .getDateTimeInstance(DateFormat.MEDIUM, DateFormat.SHORT)
  .format(date);

Avec cette méthode, nous transmettons des modèles de style - dans notre cas, MEDIUM pour la date et SHORT pour l'heure.

La classe Formatter en action

La classe Formatter est un autre moyen simple d'acquérir la même chaîne que les instances précédentes. Bien que ce ne soit pas l'approche la plus lisible, il s'agit d'une ligne unique thread-safe qui pourrait être bénéfique, en particulier dans un environnement multi-thread (notons que SimpleDateFormat n'est pas thread-safe) :

String strFormattedDate = String.format("%1$tb %1$te, %1$tY %1$tI:%1$tM %1$Tp", date);

Nous avons utilisé 1$ pour indiquer qu'un seul argument serait passé avec chaque indicateur.

Utilisation de l'API Java 8 Date/Heure pour la conversion

Nous devrions utiliser l'API Date/Heure de Java 8 au lieu des classes java.util.Date et java.util.Calendar dans la mesure du possible. Voyons comment nous pouvons l'utiliser pour convertir un objet Date en String. Nous utiliserons cette fois la classe DateTimeFormatter et sa fonction format(), ainsi que le même modèle de date que ci-dessus :

DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(DATE_FORMAT);

Nous devons transformer notre objet Date en objet Instant pour utiliser la nouvelle API :

Instant codeInstant = date.toInstant();

Nous devons également convertir l'objet Instant en LocalDateTime car notre chaîne attendue comporte à la fois des composants de date et d'heure :

LocalDateTime ldt = codeInstant
  .atZone(ZoneId.of("CET"))
  .toLocalDateTime();

Enfin, nous pouvons facilement obtenir notre String formaté :

String formattedDate = ldt.format(formatter);

Comment utiliser JDK 8 pour modifier le format de date dans une chaîne Java

Pour modifier le format de date de String dans Java 8, utilisez la classe DateTimeFormatter dans JDK 8. Les procédures sont les mêmes, sauf que nous utiliserons les classes DateTimeFormatter et LocalDateTime au lieu de SimpleDateFormat et Date.

Dans Java 8, la classe DateTimeFormatter formate et analyse les dates, tandis que LocalDateTime représente une date avec l'heure locale. En fonction de votre modèle, vous pouvez sélectionner la classe appropriée. La classe LocalDatetime est appropriée pour convertir le format "aaaa-MM-jj hh:mm:ss" en "aaaa-MM-jj". Si votre modèle ne contient qu'une date, une classe LocalDate est utilisée à la place.

Quoi qu'il en soit, voici un exemple de code de JDK 8 pour modifier le format de date dans une chaîne Java :

DateTimeFormatter dtFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
DateTimeFormatter dtNewPattern = DateTimeFormatter.ofPattern("yyyy-MM-dd");

LocalDateTime localDateTime = LocalDateTime.parse(input, dtFormatter);
String dateOutput = localDateTime.format(dtNewPattern);

Les processus sont les mêmes, mais le code est robuste en raison de l'expressivité, de la sécurité des threads et de l'immuabilité de DateTimeFormatter. En général, si vous utilisez JDK 8, utilisez la nouvelle API Date et heure pour tout nouveau code que vous développez et qui a quelque chose à voir avec les dates. Passez un peu de temps à apprendre les classes fondamentales, telles que LocalDate, LocalTime, LocalDateTime, ZonedDateTime, DateTimeFormatter, etc. mois et année.

Modification du format de date dans une chaîne Java avant JDK 8

Si vous n'utilisez pas JDK 8, vous devrez vous fier à l'API obsolète de date et de calendrier. Pour modifier le format de date, utilisez la classe SimpleDateFormat. Voici les étapes à suivre :

1) Utilisez l'ancienne approche pour créer un format de date.

SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

2) Convertir la chaîne en date en utilisant le format suivant :

Date newDate = simpleFormat.parse(input);

3) Ajoutez le nouveau modèle à un DateFormat.

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

4) À l'aide du format de date du nouveau modèle, convertissez la date en chaîne.

String output = simpleDateFormat.format(date);

C'est tout ce qu'il y a; vous avez maintenant une chaîne au format souhaité. Bien que vous deviez utiliser la classe SimpleDateFormat avec précaution, elle n'est pas thread-safe et ne doit pas être partagée dans un contexte multi-threading. Comme les lettres sont sensibles à la casse, "aaaa-mm-jj" et "aaaa-MM-jj" ne sont pas interchangeables. Le minuscule m représente une minute, tandis que le grand M représente un mois.

Exemple :programme pour formater la date actuelle en chaîne et l'imprimer

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.Date;

public class CodeDateToString {
// this is the main execution point of the program 
   public static void main(String args[]) throws Exception,ParseException {

      // current date retrieval
      LocalDate localDate = LocalDate.now();

      //Conversion of a LocalDate object to Date
      Date dateNow = java.sql.Date.valueOf(localDate);

      //SimpleDateFormat class instantiation
      SimpleDateFormat simpleFormatter = new SimpleDateFormat("dd-MM-yyyy");

      //Formatting the date value obtained
      String dateFormatted = simpleFormatter.format(dateNow);
      System.out.println("Formatted date: "+dateFormatted);
   }
}

Exemple :Utilisation de la méthode LocalDate.toString()

  • Obtenez une instance LocalDate à partir de la date.
  • Utilisez la fonction toString() de la classe LocalDate pour convertir la date donnée en chaîne.
  • Imprimez le résultat.
//  program for converting Date to String in Java

import java.time.LocalDate;

class Codeunderscored {

	// Function for date to string conversion
	public static String
	convertDateToString(String newDate)
	{

		// Getting LocalTime  instance from date
		LocalDate codeDate = LocalDate.parse(newDate);

		// Converting the date provided  into a string through the toString()method
		String dateToString= codeDate.toString();

		// returning the resultant outcome
		return (dateToString);
	}

	// This is the main methods' driver Code
	public static void main(String args[])
	{

		// Date provided
		String newDate = "2022-05-22";

		// Converting and printing the result
		System.out.print(convertDateToString(newDate));
	}
}

Exemple :Utilisation de la méthode DateFormat.format()

  • Obtenez la date que vous souhaitez convertir.
  • Lors du formatage de la représentation sous forme de chaîne de l'objet date, créez une instance de la classe SimpleDateFormat.
  • À l'aide de l'objet Calendrier, obtenez la date actuelle.
  • La méthode format() convertit une date en une chaîne.
  • Imprimez le résultat.
// program for converting the Date to String in Java

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

class Codeunderscored {

	// Date to string conversion function
	public static String
	convertDateToString(String date)
	{
		//Converts a string into a date object.
		DateFormat dateFormat = new SimpleDateFormat(date);

		// Using the calendar object, get the date.
		Date codeToday = Calendar.getInstance().getTime();

		// Using the format() method, convert the date to a string.
		String codeDateToString = dateFormat.format(codeToday);

		// Return the outcome
		return (codeDateToString);
	}

	// This is the main method
	public static void main(String args[])
	{

		// Given Date
		String newDate = "07-27-2020";

		// Conversion and result and printing
		System.out.print(convertDateToString(newDate));
	}
}

Exemple :Programme de conversion de date d'un format à un autre en Java

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class CodeDateConversion {

  public static void main(String[] args) throws ParseException {

    String dateSample = "2022-05-22 20:10:00";

    // prior to Java 8
    SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    Date date = simpleFormat.parse(dateSample);
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

    String dateOutput = dateFormat.format(date);

    System.out.println("Date in the old format is: " + dateSample);
    System.out.println("Updated Date in the new format: " + dateOutput);

    //Using the new Date alongside the Time API in Java 8
    DateTimeFormatter dtPattern = DateTimeFormatter
        .ofPattern("yyyy-MM-dd HH:mm:ss");
    DateTimeFormatter resultantPattern = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    LocalDateTime localDateTime = LocalDateTime.parse(input, dtPattern);
    dateOutput = localDateTime.format(resultantPattern);

    System.out.println("Date in the old format (java 8) format : " + dateSample);
    System.out.println("The resultant Date in the new format (java 8) : " + dateOutput);

  }

}

Comme nous l'avons déjà dit, les étapes sont les mêmes; seules les classes changent. Les classes SimpleDateFormat et Date sont utilisées dans Java 7 et versions antérieures, tandis que les classes DateTimeFormatter et LocalDateTime sont utilisées dans Java 8.

Éléments importants à garder à l'esprit

Convertir une chaîne en date peut sembler simple, mais ce n'est pas le cas. En raison de la syntaxe difficile d'un certain modèle de format de date, de nombreux développeurs Java commettent des erreurs mineures.

Il existe également quelques différences mineures entre JDK 8 et les versions précédentes, ce qui implique qu'un modèle qui fonctionnait avec SimpleDateFormat dans JDK 8 peut ne pas fonctionner avec DateTimeFormatter, une classe équivalente de la nouvelle API Date et heure de Java 8. Par conséquent, lorsque vous fournissez un modèle, vous devez faire preuve de prudence.

Lorsque nous avons exécuté l'application pour la première fois, nous avons obtenu l'erreur suivante après avoir copié le format de SimpleDateFormat vers DateTimeFormatter dans le code précédent :

Exception in thread "main" java.time.format.DateTimeParseException:
 Text '2022-05-22 20:10:00' could not be parsed: Invalid value
for ClockHourOfAmPm (valid values 1 - 12): 20
at java.time.format.DateTimeFormatter.createError(DateTimeFormatter.java:1920)
at java.time.format.DateTimeFormatter.parse(DateTimeFormatter.java:1855)
at java.time.LocalDateTime.parse(LocalDateTime.java:492)
at codeDateConversion.main(codeDateConversion.java:28)

Le message d'erreur est clair :il attend de 1 à 12 dans la colonne des heures, ce qui implique qu'il attend une date AM/PM plutôt qu'un format 24 heures. C'était notre modèle, "aaaa-MM-jj hh:mm:ss", qui utilisait un petit h, c'est-à-dire "hh", pour indiquer l'heure de la journée.

L'erreur a disparu lorsque nous l'avons remplacée par un H majuscule, c'est-à-dire "HH". Vous n'avez peut-être pas remarqué une distinction mineure en lisant le code.

Une autre chose à retenir est que le M majuscule, "MM", est utilisé pendant des mois tandis que le petit M, "mm", est utilisé pendant des minutes. De nombreux programmeurs commettent cette erreur lors de l'écriture d'un modèle de format de date.

Par exemple, pour produire une date comme 2022-05-22, vous devez utiliser le modèle "jj-MM-aaaa", et non "jj-mm-aaaa", qui ne fonctionnera pas mais est plus facile à saisir car jj et aaaa sont dans un petit boîtier. Nous vous recommandons de suivre des cours Java approfondis si vous souhaitez en savoir plus sur le formatage des dates en Java.

Conclusion

Dans ce didacticiel, nous avons exploré comment convertir des objets Date en objets String en Java. Notez comment nous avons utilisé à la fois l'ancien type java.util.Date, les classes java.util.Calendar et la nouvelle API Date/Heure introduite dans Java 8. La classe Formatter a ensuite été utilisée, suivie de Java 8 Date/Heure API.

Pour des raisons évidentes, nous vous recommandons d'utiliser DateTimeFormatter au lieu de SimpleDateFormat si vous utilisez Java 8. Certaines des principales raisons incluent l'immuabilité et la sécurité des threads.

C'est tout ce qu'il y a à savoir sur la modification du format de date d'une chaîne en Java. Nous avons vu comment l'accomplir avant et après JDK 8. Comme nous l'avons indiqué précédemment, il s'agit d'un processus en deux étapes dans lequel vous convertissez String en date en utilisant l'ancien type de date, puis revenez en String en utilisant le nouveau format de date.


Balise Java