Convertir java.util.Date en java.time.LocalDate

Quelle est la meilleure façon de convertir un java.util.Dateobjet vers le nouveau JDK 8 / JSR-310 java.time.LocalDate?

Date input = new Date();
LocalDate date = ???

Réponse courte

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

Explication

Malgré son nom, java.util.Datereprésente un instant sur la ligne du temps, pas une "date". Les données réelles stockées dans l'objet sont un longdécompte des millisecondes depuis le 1970-01-01T00: 00Z (minuit au début de 1970 GMT / UTC).

La classe équivalente à java.util.DateJSR-310 est Instant, il existe donc une méthode pratique toInstant()pour fournir la conversion:

Date input = new Date();
Instant instant = input.toInstant();

Une java.util.Dateinstance n'a pas de concept de fuseau horaire. Cela peut sembler étrange si vous appelez toString()un java.util.Date, car le toStringest relatif à un fuseau horaire. Cependant, cette méthode utilise en fait le fuseau horaire par défaut de Java à la volée pour fournir la chaîne. Le fuseau horaire ne fait pas partie de l'état réel de java.util.Date.

Un Instantne contient pas non plus d'informations sur le fuseau horaire. Ainsi, pour convertir une Instantdate en date locale, il est nécessaire de spécifier un fuseau horaire. Il peut s'agir du fuseau par défaut - ZoneId.systemDefault()- ou il peut s'agir d'un fuseau horaire contrôlé par votre application, tel qu'un fuseau horaire issu des préférences de l'utilisateur. Utilisez la atZone()méthode pour appliquer le fuseau horaire:

Date input = new Date();
Instant instant = input.toInstant();
ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());

Un ZonedDateTimecontient un état composé de la date et de l'heure locales, du fuseau horaire et du décalage par rapport à GMT / UTC. En tant que telle, la date - LocalDate- peut être facilement extraite en utilisant toLocalDate():

Date input = new Date();
Instant instant = input.toInstant();
ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
LocalDate date = zdt.toLocalDate();

Réponse de Java 9

Dans Java SE 9, une nouvelle méthode a été ajoutée qui simplifie légèrement cette tâche:

Date input = new Date();
LocalDate date = LocalDate.ofInstant(input.toInstant(), ZoneId.systemDefault());

Cette nouvelle alternative est plus directe, créant moins de déchets et devrait donc être plus performante.

La meilleure façon est:

Date date = ...;
Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate()

Avantages de cette version:

• fonctionne quelle que soit l'entrée est une instance de java.util.Dateou c'est une sous-classe de java.sql.Date(contrairement à la manière de @ JodaStephen). Ceci est courant avec les données d'origine JDBC. java.sql.Date.toInstant()lève toujours une exception.

• c'est la même chose pour JDK8 et JDK7 avec backport JSR-310

J'utilise personnellement une classe utilitaire (mais elle n'est pas compatible avec le backport):

/**
 * Utilities for conversion between the old and new JDK date types 
 * (between {@code java.util.Date} and {@code java.time.*}).
 * 
 * <p>
 * All methods are null-safe.
 */
public class DateConvertUtils {

    /**
     * Calls {@link #asLocalDate(Date, ZoneId)} with the system default time zone.
     */
    public static LocalDate asLocalDate(java.util.Date date) {
        return asLocalDate(date, ZoneId.systemDefault());
    }

    /**
     * Creates {@link LocalDate} from {@code java.util.Date} or it's subclasses. Null-safe.
     */
    public static LocalDate asLocalDate(java.util.Date date, ZoneId zone) {
        if (date == null)
            return null;

        if (date instanceof java.sql.Date)
            return ((java.sql.Date) date).toLocalDate();
        else
            return Instant.ofEpochMilli(date.getTime()).atZone(zone).toLocalDate();
    }

    /**
     * Calls {@link #asLocalDateTime(Date, ZoneId)} with the system default time zone.
     */
    public static LocalDateTime asLocalDateTime(java.util.Date date) {
        return asLocalDateTime(date, ZoneId.systemDefault());
    }

    /**
     * Creates {@link LocalDateTime} from {@code java.util.Date} or it's subclasses. Null-safe.
     */
    public static LocalDateTime asLocalDateTime(java.util.Date date, ZoneId zone) {
        if (date == null)
            return null;

        if (date instanceof java.sql.Timestamp)
            return ((java.sql.Timestamp) date).toLocalDateTime();
        else
            return Instant.ofEpochMilli(date.getTime()).atZone(zone).toLocalDateTime();
    }

    /**
     * Calls {@link #asUtilDate(Object, ZoneId)} with the system default time zone.
     */
    public static java.util.Date asUtilDate(Object date) {
        return asUtilDate(date, ZoneId.systemDefault());
    }

    /**
     * Creates a {@link java.util.Date} from various date objects. Is null-safe. Currently supports:<ul>
     * <li>{@link java.util.Date}
     * <li>{@link java.sql.Date}
     * <li>{@link java.sql.Timestamp}
     * <li>{@link java.time.LocalDate}
     * <li>{@link java.time.LocalDateTime}
     * <li>{@link java.time.ZonedDateTime}
     * <li>{@link java.time.Instant}
     * </ul>
     * 
     * @param zone Time zone, used only if the input object is LocalDate or LocalDateTime.
     * 
     * @return {@link java.util.Date} (exactly this class, not a subclass, such as java.sql.Date)
     */
    public static java.util.Date asUtilDate(Object date, ZoneId zone) {
        if (date == null)
            return null;

        if (date instanceof java.sql.Date || date instanceof java.sql.Timestamp)
            return new java.util.Date(((java.util.Date) date).getTime());
        if (date instanceof java.util.Date)
            return (java.util.Date) date;
        if (date instanceof LocalDate)
            return java.util.Date.from(((LocalDate) date).atStartOfDay(zone).toInstant());
        if (date instanceof LocalDateTime)
            return java.util.Date.from(((LocalDateTime) date).atZone(zone).toInstant());
        if (date instanceof ZonedDateTime)
            return java.util.Date.from(((ZonedDateTime) date).toInstant());
        if (date instanceof Instant)
            return java.util.Date.from((Instant) date);

        throw new UnsupportedOperationException("Don't know hot to convert " + date.getClass().getName() + " to java.util.Date");
    }

    /**
     * Creates an {@link Instant} from {@code java.util.Date} or it's subclasses. Null-safe.
     */
    public static Instant asInstant(Date date) {
        if (date == null)
            return null;
        else
            return Instant.ofEpochMilli(date.getTime());
    }

    /**
     * Calls {@link #asZonedDateTime(Date, ZoneId)} with the system default time zone.
     */
    public static ZonedDateTime asZonedDateTime(Date date) {
        return asZonedDateTime(date, ZoneId.systemDefault());
    }

    /**
     * Creates {@link ZonedDateTime} from {@code java.util.Date} or it's subclasses. Null-safe.
     */
    public static ZonedDateTime asZonedDateTime(Date date, ZoneId zone) {
        if (date == null)
            return null;
        else
            return asInstant(date).atZone(zone);
    }

}

La asLocalDate()méthode ici est null-safe, utilise toLocalDate(), si l'entrée est java.sql.Date(elle peut être remplacée par le pilote JDBC pour éviter les problèmes de fuseau horaire ou les calculs inutiles), sinon utilise la méthode susmentionnée.

LocalDate localDate = LocalDate.parse( new SimpleDateFormat("yyyy-MM-dd").format(date) );

Si vous utilisez Java 8, la réponse de @ JodaStephen est évidemment la meilleure. Cependant, si vous travaillez avec le backport JSR-310 , vous devez malheureusement faire quelque chose comme ceci:

Date input = new Date();
Calendar cal = Calendar.getInstance();
cal.setTime(input);
LocalDate date = LocalDate.of(cal.get(Calendar.YEAR),
        cal.get(Calendar.MONTH) + 1,
        cal.get(Calendar.DAY_OF_MONTH));

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

Vous pouvez convertir en une seule ligne:

public static LocalDate getLocalDateFromDate(Date date){
   return LocalDate.from(Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()));
}

tout d'abord, il est facile de convertir une date en instantané

Instant timestamp = new Date().toInstant(); 

Ensuite, vous pouvez convertir l'instantané en n'importe quelle API de date dans jdk 8 en utilisant la méthode ofInstant ():

LocalDateTime date = LocalDateTime.ofInstant(timestamp, ZoneId.systemDefault()); 

Date input = new Date();
LocalDateTime  conv=LocalDateTime.ofInstant(input.toInstant(), ZoneId.systemDefault());
LocalDate convDate=conv.toLocalDate();

L' Dateinstance contient également l'heure ainsi que la date alors que ce LocalDaten'est pas le cas. Ainsi, vous pouvez d'abord le convertir en LocalDateTimeutilisant sa méthode, ofInstant()puis si vous le souhaitez sans temps, convertissez l'instance en LocalDate.

public static LocalDate Date2LocalDate(Date date) {
        return LocalDate.parse(date.toString(), DateTimeFormatter.ofPattern("EEE MMM dd HH:mm:ss zzz yyyy"))

ce format est de Date#tostring

    public String toString() {
        // "EEE MMM dd HH:mm:ss zzz yyyy";
        BaseCalendar.Date date = normalize();
        StringBuilder sb = new StringBuilder(28);
        int index = date.getDayOfWeek();
        if (index == BaseCalendar.SUNDAY) {
            index = 8;
        }
        convertToAbbr(sb, wtb[index]).append(' ');                        // EEE
        convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' ');  // MMM
        CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 2).append(' '); // dd

        CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':');   // HH
        CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':'); // mm
        CalendarUtils.sprintf0d(sb, date.getSeconds(), 2).append(' '); // ss
        TimeZone zi = date.getZone();
        if (zi != null) {
            sb.append(zi.getDisplayName(date.isDaylightTime(), TimeZone.SHORT, Locale.US)); // zzz
        } else {
            sb.append("GMT");
        }
        sb.append(' ').append(date.getYear());  // yyyy
        return sb.toString();
    }

J'ai eu des problèmes avec l'implémentation de @ JodaStephen sur JBoss EAP 6. J'ai donc réécrit la conversion en suivant le tutoriel Java d'Oracle dans http://docs.oracle.com/javase/tutorial/datetime/iso/legacy.html .

    Date input = new Date();
    GregorianCalendar gregorianCalendar = (GregorianCalendar) Calendar.getInstance();
    gregorianCalendar.setTime(input);
    ZonedDateTime zonedDateTime = gregorianCalendar.toZonedDateTime();
    zonedDateTime.toLocalDate();

Quel est le problème avec cette 1 ligne simple?

new LocalDateTime(new Date().getTime()).toLocalDate();

J'ai résolu cette question avec la solution ci-dessous

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

Dans ce cas localDate imprimez votre date dans ce format "aaaa-MM-jj"