Java >> Java tutorial >  >> Tag >> String

Sådan formateres en dato til streng i Java

String

Ændring af datoformatet for en given dato eller streng er en typisk Java-programmeringsopgave. Antag for eksempel, at du har "2022-05-22 12:00:00" og vil konvertere det til "2022-05-22", eller konvertere fra dd-MM-ÅÅ til MM-dd-ÅÅ eller en hvilken som helst anden format du kan lide, så længe det er et gyldigt datoformat som defineret af Java. Hvordan vil du opnå dette? Det er jo ikke så svært. Det er en simpel to-trins procedure.

Det ville hjælpe, hvis du først parsede String for at konstruere en tilsvarende dato i det eksisterende format og derefter konverterede datoen tilbage til String i det nye format. Fremgangsmåden ligner Java 8 og tidligere, bortset fra API og klasseændringer.

Format()-funktionen i pakken java.text.DateFormat bruges til at konvertere Date til String i Java.

Klassen java.text.SimpleDateFormat bruges til at parse og formatere datoer i henhold til et brugerdefineret formateringsmønster. Java SimpleDateFormat bruger normalt en Java-streng som kilde ved behandling af datoer. Når du formaterer datoer, konverterer SimpleDateFormat et Date-objekt til en String, men det kan også konvertere et Date-objekt til en StringBuffer. SimpleDateFormat-klassen er ansvarlig for formatering af datoer i denne tekst.

SimpleDateFormat-oprettelse

Opret et SimpleDateFormat-objekt som følger:

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

Datoparsing og formateringsmønster er specificeret af mønsterparameteren, der leveres til SimpleDateFormat-konstruktøren. En standard Java-streng bruges som mønsteret.

Datoformatering

Når du har genereret en SimpleDateFormat-instans, kan du bruge dens format()-funktion til at formatere datoer. Overvej følgende scenarie:

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

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

Format()-funktionen tager en java.util.Date-instans som et argument. Følgende er output fra SimpleDateFormat-eksemplet:

2022-05-22

Bemærk, hvordan den formaterede datostreng begynder med år, måned og dag. Datomønsteret, der leveres til SimpleDateFormat-konstruktøren, bestemmer rækkefølgen af ​​datofelterne. Som tidligere nævnt diskuteres dette format yderligere i denne Java SimpleDateFormat-lektion.

StringBuffer med datoformat

I stedet for at returnere en individuel streng med den forberedte dato, kan Java SimpleDateFormat-klassen formatere et Date-objekt til en StringBuffer. Det opnås gennem SimpleDateFormat-klassens format()-metode, som tager Date, StringBuffer og en FieldPosition-forekomst som input. Her er et eksempel på brug af Java SimpleDateFormat til at formatere en dato til en 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));

Det er uklart, hvordan FieldPosition-instansen bruges. Uanset hvilken int-værdi, der leveres til FieldPosition-konstruktøren, tilføjer format()-metoden den formaterede streng til slutningen af ​​StringBuffer.

Parseringsdatoer

Parse()-metoden i klassen SimpleDateFormat konverterer en streng til en java.util.Date-instans. Overvej følgende scenarie:

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

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

Når denne kode er kørt, peger datovariablen på en Dato-forekomst, der afspejler den 22. maj 2022.

Oprettelse af et lokalitetsspecifikt SimpleDateFormat

En SimpleDateFormat-instans oprettes for en specificeret Java-lokalitet. Datoerne vil blive formateret i henhold til lokaliteten, når dette er gjort. Et formateringsmønster, der f.eks. inkluderer navnet på ugedagen, vil skrive ugedagen på det valgte sprog. Overvej følgende scenarie:

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

Andre tegn end disse vil blive indsat i mønsteret som normal tekst og dermed i de formaterede datoer. Nogle tegn bruges i flere kombinationer. For eksempel kan du skrive yy for en to-tegns version af året (f.eks. 22) eller yyyy for en fire-tegns version af året. (f.eks. 2022). Se JavaDoc for SimpleDateFormat-klassen for yderligere information om de acceptable mønstre.

Eksempler på mønstre

Her er nogle forekomster af Java SimpleDateFormat-datomønstre:

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

Datoformatsymboler

Du kan ændre datosymbolerne, der bruges i det formaterede output for en bestemt lokalitet. En java.text bruges til at opnå dette. Forekomst af DateFormatSymbols. Overvej følgende scenarie:

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

For det andet er der etableret et nyt sæt af ugedagsnavne. Du skal bemærke, at den indledende streng, "ubrugt", aldrig bruges. For at kunne indekseres med kalender.SUNDAY, Calendar.MONDAY og andre konstanter, skal indeksene i denne matrix begynde med én. Calendar.SUNDAY er 1, Calendar.MONDAY er 2, og så videre. For det tredje, ved hjælp af DateFormatSymbols, bygges et SimpleDateFormat, og datoen formateres. Følgende er et eksempel på, hvordan output kan se ud:

Sunday, May 2022

Vær opmærksom på, hvordan det tilpassede ugedagsnavn bruges. På DateFormatSymbols-forekomsten kan du tilføje ekstra datoformateringssymboler. Følgende er procedurerne for tilføjelse af ekstra symboler:

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

SimpleDateFormats tidszoneindstilling

Indtil videre har alle eksemplerne i denne lektion brugt systemets standardtidszone. Hvis du vil formatere en dato, vil SimpleDateFormat antage, at du vil formatere den i henhold til systemets tidszone. Dette er dog muligvis ikke altid tilfældet.

Metoden setTimeZone() i et SimpleDateFormat ændrer tidszonen. Funktionen setTimeZone() tager som argument en Java TimeZone-instans (java.util.TimeZone). Her er et eksempel på, hvordan man ændrer en Java SimpleDateFormat-forekomsts tidszone:

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

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

SimpleDateFormat vil ændre sin formatering, når tidszonen er indstillet. Her er et eksempel på at ændre tidszonen til to adskilte tidszoner, mens du formaterer den samme dato:

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

DateFormats format()-metode

For at konvertere en dato til en streng skal du bruge format()-funktionen i klassen DateFormat. DateFormat er en generisk type. SimpleDateFormat er en DateFormat-barneklasse. Det er, hvordan DateFormat-klassen implementeres. Format()-metodens signatur er som følger:

String format(Date d)

Eksempel på Java Date to String

Lad os se på en simpel Java-kode til at konvertere Dato til String.

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

  }  
}

Lad os tage et kig på hele eksemplet med konvertering af dato og klokkeslæt til String i Java ved hjælp af format()-funktionen i klassen 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);  
    }  
    }

java.util.Datokonvertering til streng

Selvom vi ikke bør bruge java.util.Date, når vi har at gøre med Java 8, er der situationer, hvor vi ikke har et valg (f.eks. når Date-objektet kommer fra et bibliotek, vi ikke kontrollerer). Under sådanne omstændigheder har vi adskillige muligheder for at konvertere java.util.Date til String.

Gør datoobjektet klar :Lad os starte med at erklære en forventet String-repræsentation af vores dato og et datoformatmønster:

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

Nu har vi brug for et faktisk Dato-objekt til at konvertere. For at gøre det bruger vi en Kalender-forekomst:

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

For at undgå komplikationer, når du senere arbejder med den nye API, har vi sat standardtidszonen til CET. Date-objektet har ikke en tidszone, men dets toString()-metode bruger den aktuelle standardtidszone. Denne Dato-forekomst bruges i alle de følgende eksempler.

Brug af DateFormat Abstract Class

SimpleDateFormat er en underklasse af den abstrakte DateFormat-klasse, som vi kan se. Denne klasse indeholder metoder til formatering af datoer og tidspunkter. Vi bruger det til at få det samme resultat som før:

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

Med denne metode videregiver vi stilmønstre - i vores tilfælde MEDIUM for datoen og KORT for tiden.

Formaterklassen i aktion

Formatter-klassen er en anden enkel måde at erhverve den samme streng som tidligere forekomster. Selvom det ikke er den mest læsbare tilgang, er det en trådsikker one-liner, der kan være gavnlig, især i et multi-threaded miljø (vi skal bemærke, at SimpleDateFormat ikke er trådsikkert):

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

Vi brugte 1$ for at indikere, at der kun ville blive sendt et argument med hvert flag.

Brug af Java 8 Date/Time API til konvertering

Vi bør bruge Date/Time API fra Java 8 i stedet for klasserne java.util.Date og java.util.Calendar, når det er muligt. Lad os se på, hvordan vi kan bruge det til at konvertere et Dato-objekt til en streng. Vi bruger klassen DateTimeFormatter og dens format()-funktion denne gang sammen med det samme datomønster som ovenfor:

DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(DATE_FORMAT);

Vi skal transformere vores Date-objekt til et Instant-objekt for at bruge den nye API:

Instant codeInstant = date.toInstant();

Vi skal også konvertere Instant-objektet til LocalDateTime, fordi vores forventede streng har både dato- og tidskomponenter:

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

Endelig kan vi nemt få vores formaterede streng:

String formattedDate = ldt.format(formatter);

Sådan bruges JDK 8 til at ændre datoformatet i en Java-streng

For at ændre datoformatet for String i Java 8 skal du bruge DateTimeFormatter-klassen i JDK 8. Procedurerne er de samme, bortset fra at vi bruger DateTimeFormatter og LocalDateTime-klassen i stedet for SimpleDateFormat og Date.

I Java 8 formaterer klassen DateTimeFormatter og parser datoer, mens LocalDateTime repræsenterer en dato med lokal tid. Afhængigt af dit mønster kan du vælge den passende klasse. LocalDatetime-klassen er passende til at konvertere formatet "åååå-MM-dd tt:mm:ss" til "åååå-MM-dd." Hvis dit mønster kun indeholder en dato, bruges der i stedet en LocalDate-klasse.

Uanset hvad, her er et kodeeksempel fra JDK 8 til at ændre datoformatet i en Java-streng:

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

Processerne er de samme, men koden er robust på grund af DateTimeFormatters udtryksevne, trådsikkerhed og uforanderlighed. Generelt, hvis du bruger JDK 8, skal du bruge den nye Date and Time API til enhver ny kode, du udvikler, som har noget at gøre med datoer. Brug lidt tid på at lære de grundlæggende klasser, såsom LocalDate, LocalTime, LocalDateTime, ZonedDateTime, DateTimeFormatter osv. De fleste typiske opgaver er blevet forenklet, såsom at konvertere en streng til en dato og omvendt, formatering og parsing af datoer og udtrækning af dag, måned og år.

Ændring af datoformatet i en Java-streng før JDK 8

Hvis du ikke bruger JDK 8, bliver du nødt til at stole på den forældede dato og kalender API. Brug klassen SimpleDateFormat for at ændre datoformatet. Her er de trin, du skal tage:

1) Brug den gamle tilgang til at oprette et datoformat.

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

2) Konverter streng til dato ved hjælp af følgende format:

Date newDate = simpleFormat.parse(input);

3) Tilføj det nye mønster til et DateFormat.

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

4) Brug det nye mønsters Dateformatter til at konvertere datoen til en streng.

String output = simpleDateFormat.format(date);

Det er alt der er; du har nu en streng i det ønskede format. Selvom du bør bruge SimpleDateFormat-klassen med forsigtighed, er den ikke trådsikker og bør ikke deles i en multi-threading-kontekst. Fordi bogstaver skelner mellem store og små bogstaver, er "åååå-mm-dd" og "åååå-MM-dd" ikke udskiftelige. Det lille m står i et minut, mens det store M står i en måned.

Eksempel:Program til at formatere den aktuelle dato til en streng og udskrive den

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

Eksempel:Brug af metoden LocalDate.toString()

  • Få en LocalDate-forekomst fra dato.
  • Brug funktionen toString() i klassen LocalDate til at konvertere den givne dato til en streng.
  • Udskriv resultatet.
//  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));
	}
}

Eksempel:Brug af metoden DateFormat.format()

  • Få den dato, du vil konvertere.
  • Når du formaterer strengrepræsentationen af ​​datoobjektet, skal du oprette en forekomst af klassen SimpleDateFormat.
  • Hent den aktuelle dato ved hjælp af kalenderobjektet.
  • Format()-metoden konverterer en dato til en streng.
  • Udskriv resultatet.
// 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));
	}
}

Eksempel:Program til konvertering af Dato fra et format til et andet i 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);

  }

}

Som vi allerede har sagt, er stadierne de samme; bare klasserne ændrer sig. Klasserne SimpleDateFormat og Date bruges i Java 7 og tidligere, mens klasserne DateTimeFormatter og LocalDateTime bruges i Java 8.

Vigtige ting at huske på

Konvertering af en streng til dato kan virke simpel, men det er det ikke. På grund af den vanskelige syntaks for et bestemt mønster for datoformat, begår mange Java-udviklere mindre fejl.

Der er også nogle mindre forskelle mellem JDK 8 og tidligere versioner, hvilket indebærer, at et mønster, der fungerede med SimpleDateFormat i JDK 8, muligvis ikke virker med DateTimeFormatter, en tilsvarende klasse fra Java 8s nye Date and Time API. Som et resultat skal du være forsigtig, mens du angiver et mønster.

Da vi først kørte programmet, fik vi følgende fejl efter at have kopieret formatet fra SimpleDateFormat til DateTimeFormatter i den forrige kode:

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)

Fejlmeddelelsen er klar:den forventer 1 til 12 i timekolonnen, hvilket betyder, at den forventer en AM/PM-dato i stedet for et 24-timers format. Dette var vores mønster, "åååå-MM-dd tt:mm:ss", som brugte et lille h, dvs. "tt", til at angive tidspunktet på dagen.

Fejlen forsvandt, da vi ændrede den til et stort H, altså "HH." Du har muligvis ikke bemærket en mindre forskel, mens du læste koden.

En anden ting at huske er, at det store M, "MM," bruges i flere måneder, mens det lille M, "mm," bruges i minutter. Mange programmører begår denne fejl, mens de skriver et datoformatmønster.

For at producere en dato som 2022-05-22 skal du f.eks. bruge mønsteret "dd-MM-åååå," ikke "dd-mm-åååå", som ikke virker, men er nemmere at indtaste, fordi både dd og åååå er i en lille sag. Vi anbefaler at tage grundige Java-kurser, hvis du vil forstå mere om datoformatering i Java.

Konklusion

I denne øvelse har vi undersøgt, hvordan man konverterer Dato-objekter til String-objekter i Java. Bemærk, hvordan vi har brugt både den ældre java.util.Date type, java.util.Calendar klasserne og den nye Date/Time API er introduceret i Java 8. Formatter-klassen blev derefter brugt, efterfulgt af Java 8 Date/Time API.

Af indlysende årsager anbefaler vi at bruge DateTimeFormatter i stedet for SimpleDateFormat, hvis du bruger Java 8. Nogle af de udestående årsager omfatter uforanderlighed og trådsikkerhed.

Det er alt, hvad der er at vide om at ændre datoformatet for en streng i Java. Vi har set, hvordan man opnår det før og efter JDK 8. Som vi tidligere har nævnt, er det en to-trins proces, hvor du konverterer String til dato ved hjælp af den gamle datotype og derefter tilbage til String ved hjælp af det nye datoformat.


Java tag