Convert java.util.Date to java.time.LocalDate

Short answer

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

Explanation

Despite its name, java.util.Date represents an instant on the time-line, not a "date". The actual data stored within the object is a long count of milliseconds since 1970-01-01T00:00Z (midnight at the start of 1970 GMT/UTC).

The equivalent class to java.util.Date in JSR-310 is Instant, thus there is a convenient method toInstant() to provide the conversion:

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

A java.util.Date instance has no concept of time-zone. This might seem strange if you call toString() on a java.util.Date, because the toString is relative to a time-zone. However that method actually uses Java's default time-zone on the fly to provide the string. The time-zone is not part of the actual state of java.util.Date.

An Instant also does not contain any information about the time-zone. Thus, to convert from an Instant to a local date it is necessary to specify a time-zone. This might be the default zone - ZoneId.systemDefault() - or it might be a time-zone that your application controls, such as a time-zone from user preferences. Use the atZone() method to apply the time-zone:

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

A ZonedDateTime contains state consisting of the local date and time, time-zone and the offset from GMT/UTC. As such the date - LocalDate - can be easily extracted using toLocalDate():

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

Java 9 answer

In Java SE 9, a new method has been added that slightly simplifies this task:

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

This new alternative is more direct, creating less garbage, and thus should perform better.

Better way is:

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

Advantages of this version:

• works regardless the input is an instance of java.util.Date or it's a subclass of java.sql.Date (unlike @JodaStephen's way). This is common with JDBC-originated data. java.sql.Date.toInstant() always throws an exception.

• it's the same for JDK8 and JDK7 with JSR-310 backport

I personally use an utility class (but it is not backport-compatible):

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

The asLocalDate() method here is null-safe, uses toLocalDate(), if input is java.sql.Date (it may be overriden by the JDBC driver to avoid timezone problems or unnecessary calculations), otherwise uses the abovementioned method.

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