将java.util.Date转换为java.time.LocalDate

将

java.util.Date

对象转换为新的JDK 8/JSR-310

java.time.LocalDate

的最佳方法是什么

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

---

简短回答

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

解释

尽管名称不同，

java.util.Date

表示时间线上的一个瞬间，而不是“日期”。对象中存储的实际数据是自1970-01-01T00:00Z（1970 GMT/UTC开始时的午夜）以来的

长

毫秒计数

JSR-310中与

java.util.Date

等效的类是

Instant

，因此有一种方便的方法

toInstant（）

来提供转换：

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

java.util.Date

实例没有时区的概念。如果在

java.util.Date

上调用

toString（）

，这可能看起来很奇怪，因为

toString

是相对于时区的。然而，该方法实际上使用Java的默认时区动态提供字符串。时区不是

java.util.Date

的实际状态的一部分

即时

也不包含任何关于时区的信息。因此，要将

即时日期

转换为本地日期，必须指定时区。这可能是默认区域-

ZoneId.systemDefault（）

，也可能是应用程序控制的时区，例如用户首选项中的时区。使用

atZone（）

方法应用时区：

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

ZonedDateTime

包含由本地日期和时间、时区以及与GMT/UTC的偏移量组成的状态。因此，可以使用

toLocalDate（）

轻松提取日期--

LocalDate

：

Java 9答案

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

在Java SE 9中，添加了一个稍微简化此任务的：

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

---

这个新的替代方案更直接，产生的垃圾更少，因此性能应该更好。

如果您使用的是Java 8，@JodaStephen的答案显然是最好的。但是，如果您正在使用，很不幸，您必须执行以下操作：

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

更好的方法是：

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

此版本的优点：

• 无论输入是

  java.util.Date

  的实例还是

  java.sql.Date

  的子类（与@JodaStephen的方式不同），都可以工作。这在源于JDBC的数据中很常见

  java.sql.Date.toInstant（）

  始终引发异常

• 使用JSR-310后端口的JDK8和JDK7也是如此

我个人使用一个实用程序类（但它不兼容backport）：

/**
*用于新旧JDK日期类型之间转换的实用程序
*（在{@code java.util.Date}和{@code java.time.*}之间）。
* 
*
*所有方法都是空安全的。
*/
公共类DateConvertUtils{
/**
*使用系统默认时区调用{@link#asLocalDate（Date，ZoneId）}。
*/
公共静态LocalDate asLocalDate（java.util.Date）{
返回asLocalDate（日期，ZoneId.systemDefault（））；
}
/**
*从{@code java.util.Date}或其子类.Null-safe创建{@link LocalDate}。
*/
publicstaticlocaldateaslocaldate（java.util.Date-Date，ZoneId-zone）{
如果（日期==null）
返回null；
if（java.sql.date的日期实例）
return（（java.sql.Date）Date.toLocalDate（）；
其他的
返回Instant.ofEpochMilli（date.getTime（））.atZone（zone.toLocalDate（）；
}
/**
*使用系统默认时区调用{@link#asLocalDateTime（Date，ZoneId）}。
*/
公共静态LocalDateTime asLocalDateTime（java.util.Date-Date）{
返回asLocalDateTime（日期，ZoneId.systemDefault（））；
}
/**
*从{@code java.util.Date}或其子类.Null-safe创建{@link LocalDateTime}。
*/
公共静态LocalDateTime asLocalDateTime（java.util.Date日期，ZoneId区域）{
如果（日期==null）
返回null；
if（java.sql.Timestamp的日期实例）
return（（java.sql.Timestamp）date）.toLocalDateTime（）；
其他的
返回Instant.ofEpochMilli（date.getTime（））.atZone（zone.toLocalDateTime（）；
}
/**
*使用系统默认时区调用{@link#asUtilDate（Object，ZoneId）}。
*/
公共静态java.util.Date asUtilDate（对象日期）{
返回asUtilDate（日期，ZoneId.systemDefault（））；
}
/**
*从各种日期对象创建{@link java.util.Date}。是空安全的。当前支持：

*
{@link java.util.Date}
*
{@link java.sql.Date}
*
{@link java.sql.Timestamp}
*
{@link java.time.LocalDate}
*
{@link java.time.LocalDateTime}
*
{@link java.time.ZonedDateTime}
*
{@link java.time.Instant}
*
* 
*@param zone Time zone，仅当输入对象为LocalDate或LocalDateTime时使用。
* 
*@return{@link java.util.Date}（就是这个类，而不是子类，比如java.sql.Date）
*/
公共静态java.util.Date asUtilDate（对象日期，ZoneId区域）{
如果（日期==null）
返回null；
if（date instanceof java.sql.date | | date instanceof java.sql.Timestamp）
返回新的java.util.Date（（（java.util.Date）Date.getTime（））；
if（java.util.date的日期实例）
返回（java.util.Date）日期；
if（日期实例of LocalDate）
返回java.util.Date.from（（LocalDate）Date.atStartOfDay（zone.toInstant（））；
if（LocalDateTime的日期实例）
返回java.util.Date.from（（LocalDateTime）Date.atZone（zone.toInstant（））；
if（ZonedDateTime的日期实例）
返回java.util.Date.from（（（ZonedDateTime）Date.toInstant（））；
如果（日期实例或瞬间）
返回java.util.Date.from（（即时）日期）；
抛出新的UnsupportedOperationException（“不知道热转换“+date.getClass（）.getName（）+”到java.util.Da
/**
 * 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);
    }

}

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

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

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

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

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

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

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

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

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

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

    Date input = new Date(); // Imagine your Date here
    LocalDate date = DateTimeUtils.toInstant(input)
            .atZone(ZoneId.systemDefault())
            .toLocalDate();