O Java 8 possui uma API completamente nova para data e hora. Uma das classes mais úteis nessa API é LocalDateTimea retenção de um valor de data e hora independente do fuso horário.

Provavelmente existem milhões de linhas de código usando a classe herdada java.util.Datepara esse fim. Como tal, ao fazer a interface de código antigo e novo, será necessário converter entre os dois. Como parece não haver métodos diretos para fazer isso, como isso pode ser feito?

Resposta curta:

Date in = new Date();
LocalDateTime ldt = LocalDateTime.ofInstant(in.toInstant(), ZoneId.systemDefault());
Date out = Date.from(ldt.atZone(ZoneId.systemDefault()).toInstant());

Explicação: (com base nesta pergunta sobre LocalDate)

Apesar do nome, java.util.Daterepresenta um instante na linha do tempo, não uma "data". Os dados reais armazenados no objeto são umlong contagem de milissegundos desde 01-01-2009 - 00: 00Z (meia-noite no início de 1970 GMT / UTC).

A classe equivalente java.util.Datena JSR-310 é Instant, portanto, existem métodos convenientes para fornecer a conversão de um lado para outro:

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

Uma java.util.Dateinstância não tem conceito de fuso horário. Isso pode parecer estranho se você chamar toString()um java.util.Date, porque toStringé relativo a um fuso horário. No entanto, esse método realmente usa o fuso horário padrão de Java rapidamente para fornecer a string. O fuso horário não faz parte do estado real de java.util.Date.

Um Instanttambém não contém nenhuma informação sobre o fuso horário. Portanto, para converter de uma Instantdata para hora local, é necessário especificar um fuso horário. Esse pode ser o fuso horário padrão - ZoneId.systemDefault()- ou pode ser um fuso horário que seu aplicativo controla, como um fuso horário nas preferências do usuário. LocalDateTimepossui um método conveniente de fábrica que utiliza o instante e o fuso horário:

Date in = new Date();
LocalDateTime ldt = LocalDateTime.ofInstant(in.toInstant(), ZoneId.systemDefault());

Ao contrário, o LocalDateTimefuso horário é especificado chamando o atZone(ZoneId)método O ZonedDateTimepode então ser convertido diretamente em um Instant:

LocalDateTime ldt = ...
ZonedDateTime zdt = ldt.atZone(ZoneId.systemDefault());
Date output = Date.from(zdt.toInstant());

Observe que a conversão de LocalDateTimepara ZonedDateTimetem o potencial de introduzir um comportamento inesperado. Isso ocorre porque nem todas as datas locais existem devido ao horário de verão. No outono / outono, há uma sobreposição na linha do tempo local, onde a mesma data e hora local ocorre duas vezes. Na primavera, há uma lacuna, onde uma hora desaparece. Veja o Javadoc deatZone(ZoneId) para obter mais a definição do que a conversão fará.

Resumo, se você ida e volta uma java.util.Datea uma LocalDateTimee de volta a um java.util.Datevocê pode acabar com um instante diferente devido ao horário de verão.

Informações adicionais: Há outra diferença que afetará datas muito antigas. java.util.Dateusa um calendário que muda em 15 de outubro de 1582, com datas anteriores a usar o calendário juliano em vez do calendário gregoriano. Por outro lado, java.time.*usa o sistema de calendário ISO (equivalente ao gregoriano) para todos os tempos. Na maioria dos casos de uso, o sistema de calendário ISO é o que você deseja, mas você pode observar efeitos estranhos ao comparar datas anteriores ao ano de 1582.

Aqui está o que eu criei (e, como todos os enigmas de Data e Hora, provavelmente será refutado com base em algum ajuste estranho de fuso horário - salto durante o dia: D)

Rodada: Date<<->>LocalDateTime

Dado: Date date = [some date]

(1) LocalDateTime<< Instant<<Date

    Instant instant = Instant.ofEpochMilli(date.getTime());
    LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);

(2) Date<< Instant<<LocalDateTime

    Instant instant = ldt.toInstant(ZoneOffset.UTC);
    Date date = Date.from(instant);

Exemplo:

Dado:

Date date = new Date();
System.out.println(date + " long: " + date.getTime());

(1) LocalDateTime<< Instant<< Date:

Criar a Instantpartir de Date:

Instant instant = Instant.ofEpochMilli(date.getTime());
System.out.println("Instant from Date:\n" + instant);

Crie a Datepartir de Instant(não necessário, mas para ilustração):

date = Date.from(instant);
System.out.println("Date from Instant:\n" + date + " long: " + date.getTime());

Criar a LocalDateTimepartir deInstant

LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);
System.out.println("LocalDateTime from Instant:\n" + ldt);

(2) Date<< Instant<<LocalDateTime

Criar a Instantpartir de LocalDateTime:

instant = ldt.toInstant(ZoneOffset.UTC);
System.out.println("Instant from LocalDateTime:\n" + instant);

Criar a Datepartir de Instant:

date = Date.from(instant);
System.out.println("Date from Instant:\n" + date + " long: " + date.getTime());

A saída é:

Fri Nov 01 07:13:04 PDT 2013 long: 1383315184574

Instant from Date:
2013-11-01T14:13:04.574Z

Date from Instant:
Fri Nov 01 07:13:04 PDT 2013 long: 1383315184574

LocalDateTime from Instant:
2013-11-01T14:13:04.574

Instant from LocalDateTime:
2013-11-01T14:13:04.574Z

Date from Instant:
Fri Nov 01 07:13:04 PDT 2013 long: 1383315184574

Maneira muito mais conveniente, se você tiver certeza de que precisa de um fuso horário padrão:

Date d = java.sql.Timestamp.valueOf( myLocalDateTime );

o seguinte parece funcionar ao converter da nova API LocalDateTime para java.util.date:

Date.from(ZonedDateTime.of({time as LocalDateTime}, ZoneId.systemDefault()).toInstant());

a conversão reversa pode ser (espero) alcançada de maneira semelhante ...

espero que ajude...

Está tudo aqui: http://blog.progs.be/542/date-to-java-time

A resposta com "round-trip" não é exata: quando você faz

LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);

se o fuso horário do sistema não for UTC / GMT, você altera a hora!

A maneira mais rápida de LocalDateTime-> Dateé:

Date.from(ldt.toInstant(ZoneOffset.UTC))

Não tenho certeza se essa é a maneira mais simples ou melhor, ou se existem armadilhas, mas funciona:

static public LocalDateTime toLdt(Date date) {
    GregorianCalendar cal = new GregorianCalendar();
    cal.setTime(date);
    ZonedDateTime zdt = cal.toZonedDateTime();
    return zdt.toLocalDateTime();
}

static public Date fromLdt(LocalDateTime ldt) {
    ZonedDateTime zdt = ZonedDateTime.of(ldt, ZoneId.systemDefault());
    GregorianCalendar cal = GregorianCalendar.from(zdt);
    return cal.getTime();
}

Se você estiver no Android e estiver usando o threetenbp, poderá usar DateTimeUtils.

ex:

Date date = DateTimeUtils.toDate(localDateTime.atZone(ZoneId.systemDefault()).toInstant());

você não pode usar, Date.frompois ele é suportado apenas na API 26+