LocalDate naar java.util.Date en vice versa eenvoudigste conversie?

Is er een eenvoudige manier om een LocalDate(geïntroduceerd met Java 8) om te zetten in een java.util.Date-object?

Met ‘eenvoudig’ bedoel ik eenvoudiger dan dit:

Date date = Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());

wat mij een beetje onhandig lijkt.

Omdat we alleen geïnteresseerd zijn in het datumgedeelte en er geen tijdzone-informatie is in geen van beide objecten, waarom zou u dan expliciet tijdzones introduceren? De middernachttijd en de standaardtijdzone van het systeem moeten impliciet worden genomen voor de conversie.


Antwoord 1, autoriteit 100%

tl;dr

Is er een eenvoudige manier om een LocalDate (geïntroduceerd met Java 8) te converteren naar java.util.Date-object? Met ‘eenvoudig’ bedoel ik eenvoudiger dan dit

Nee. Je hebt het goed en zo beknopt mogelijk gedaan.

java.util.Date.from(                     // Convert from modern java.time class to troublesome old legacy class.  DO NOT DO THIS unless you must, to inter operate with old code not yet updated for java.time.
    myLocalDate                          // `LocalDate` class represents a date-only, without time-of-day and without time zone nor offset-from-UTC. 
    .atStartOfDay(                       // Let java.time determine the first moment of the day on that date in that zone. Never assume the day starts at 00:00:00.
        ZoneId.of( "America/Montreal" )  // Specify time zone using proper name in `continent/region` format, never 3-4 letter pseudo-zones such as “PST”, “CST”, “IST”. 
    )                                    // Produce a `ZonedDateTime` object. 
    .toInstant()                         // Extract an `Instant` object, a moment always in UTC.
)

Lees hieronder voor problemen en denk er dan over na. Hoe kan het eenvoudiger? Als je me vraagt hoe laat een date begint, hoe zou ik anders kunnen reageren dan je te vragen “Waar?”. Een nieuwe dag breekt eerder aan in Parijs FR dan in Montréal CA, en nog eerder in Kolkata IN, en zelfs eerder in Auckland, NZ, allemaal verschillende momenten.

Dus bij het converteren van een datum-only (LocalDate) naar een datum-tijd moeten weeen tijdzone toepassen (ZoneId) om een gezoneerde waarde (ZonedDateTime), en ga dan naar UTC (Instant) om overeen te komen met de definitie van een java.util.Date.

Details

Vermijd ten eerste de oude verouderde datum-tijdklassen zoals java.util.Datewaar mogelijk. Ze zijn slecht ontworpen, verwarrend en lastig. Ze werden om een reden vervangen door de java.time-klassen, eigenlijk om veleredenen.

Maar als het moet, kunt u van/naar java.time-typen converteren naar de oude. Zoek naar nieuwe conversiemethoden die aan de oude klassen zijn toegevoegd.

java.util.Datejava.time.LocalDate

Houd er rekening mee dat een java.util.Dateeen verkeerde benaming is, omdat het een datum pluseen tijd van de dag in UTC vertegenwoordigt. Daarentegen is de LocalDateklasse vertegenwoordigt een alleen-datum waarde zonder tijd van de dag en zonder tijdzone.

Van java.util.Datenaar java.time gaan betekent converteren naar de equivalente klasse van java.time.Instant. Het Instantclass vertegenwoordigt een moment op de tijdlijn in UTCmet een resolutie van nanoseconden(maximaal negen (9) cijfers van een decimale breuk).

Instant instant = myUtilDate.toInstant();

De LocalDateklasse vertegenwoordigt een alleen-datum waarde zonder tijd van de dag en zonder tijdzone.

Een tijdzone is cruciaal bij het bepalen van een datum. Voor elk willekeurig moment varieert de datum over de hele wereld per zone. Bijvoorbeeld, een paar minuten na middernacht in Parijs Frankrijkis een nieuwe dag terwijl nog steeds “gisteren ” in Montréal Québec.

Dus we moeten dat Instantnaar een tijdzone verplaatsen. We passen ZoneIdtoe om een ZonedDateTimete krijgen.

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

Vraag vanaf daar om een datum, een LocalDate.

LocalDate ld = zdt.toLocalDate();

java.time.LocalDatejava.util.Date

Om de andere kant op te gaan, van een java.time.LocalDatenaar een java.util.Datebetekent dat we gaan van een alleen-datum naar een datum- tijd. We moeten dus een tijd van de dag specificeren. U wilt waarschijnlijk voor het eerste moment van de dag gaan. Ga er nietvanuit dat dit 00:00:00is. Afwijkingen zoals zomertijd (DST) betekent dat het eerste moment een andere tijd kan zijn, zoals 01:00:00. Laat java.time die waarde bepalen door atStartOfDayaan te roepen op de LocalDate.

ZonedDateTime zdt = myLocalDate.atStartOfDay( z );

Extracteer nu een Instant.

Instant instant = zdt.toInstant();

Converteer dat Instantnaar java.util.Datedoor from( Instant ).

java.util.Date d = java.util.Date.from( instant );

Meer info


Over java.time

De java.timeframework is ingebouwd in Java 8 en hoger. Deze klassen vervangen de lastige oude legacydatum-tijdklassen zoals java.util.Date, Calendar, & SimpleDateFormat.

Zie voor meer informatie de Oracle-zelfstudie. En zoek Stack Overflow voor veel voorbeelden en uitleg. Specificatie is JSR 310.

Het Joda-Time-project, nu in onderhoudsmodus, adviseert migratie naar de java.timeklassen.

U kunt java.timeobjecten rechtstreeks uitwisselen met uw database. Gebruik een JDBC-stuurprogrammadat voldoet aan JDBC 4.2of hoger. Geen strings nodig, geen java.sql.*klassen. Slaapstand 5 & JPA 2.2 ondersteunt java.time.

Waar zijn de java.time-klassen te verkrijgen?

Het ThreeTen-Extra-project breidt java.time uit met extra lessen. Dit project is een proeftuin voor mogelijke toekomstige toevoegingen aan java.time. Mogelijk vindt u hier enkele nuttige klassen, zoals Interval, YearWeek, YearQuarteren meer.


Antwoord 2, autoriteit 95%

Disclaimer:hoewel het onderstaande antwoord werkt, wordt het niet aanbevolen om het in productiecode te gebruiken. De benadering in het antwoord van Basil moet in dit geval worden gevolgd.

Eigenlijk wel. Er is een statische methode valueOfin het java.sql.Dateobject dat precies dat doet. Dus we hebben

java.util.Date date = java.sql.Date.valueOf(localDate);

en dat is het. Geen expliciete instelling van tijdzones omdat de lokale tijdzone impliciet wordt genomen.

Van documenten:

De opgegeven LocalDate wordt geïnterpreteerd als de lokale datum in de local
tijdzone.

De java.sql.Datesubklassen java.util.Datedus het resultaat is ook een java.util.Date.

En voor de omgekeerde bewerking is er een toLocalDatemethode in de java.sql.Date klasse. Dus we hebben:

LocalDate ld = new java.sql.Date(date.getTime()).toLocalDate();


Antwoord 3, autoriteit 13%

Datum -> LokaleDatum:

LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

Lokale datum -> Datum:

Date date = Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());

Antwoord 4, autoriteit 3%

Datum tot LocalDate

Date date = new Date();
LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

Lokale datum tot datum

LocalDate localDate = LocalDate.now();
Date date = Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());

Antwoord 5, Autoriteit 2%

Localdatetime converteren naar java.util.date

   LocalDateTime localDateTime = LocalDateTime.now();
    ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneOffset.systemDefault());
    Instant instant = zonedDateTime.toInstant();
    Date date = Date.from(instant);
System.out.println("Result Date is : "+date);

Antwoord 6

Ik heb deze vraag opgelost met oplossing onder

 import org.joda.time.LocalDate;
  Date myDate = new Date();
  LocalDate localDate = LocalDate.fromDateFields(myDate);
  System.out.println("My date using Date" Nov 18 11:23:33 BRST 2016);
  System.out.println("My date using joda.time LocalTime" 2016-11-18);

In dit geval LocalDate drukken uw date in dit formaat “YYYY-MM-DD”


Antwoord 7

U kunt de java.util.Date-object converteren in een StringObject, dat de datum als YYYY-MM-DD opmaakt.

Localdate heeft een parse-methode die het zal converteren naar een LocalDateObject. De string moet een geldige datum vertegenwoordigen en wordt geparseerd met DateTimeFormatter.iso_Local_Date.

Datum tot localdate

LocalDate.parse(Date.toString())

Other episodes