Qual é a melhor maneira de converter um java.util.Date
objeto no novo JDK 8 / JSR-310 java.time.LocalDate
?
Date input = new Date();
LocalDate date = ???
Qual é a melhor maneira de converter um java.util.Date
objeto no novo JDK 8 / JSR-310 java.time.LocalDate
?
Date input = new Date();
LocalDate date = ???
Respostas:
Resposta curta
Date input = new Date();
LocalDate date = input.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
Explicação
Apesar do nome, java.util.Date
representa um instante na linha do tempo, não uma "data". Os dados reais armazenados no objeto são uma long
contagem de milissegundos desde 01-01-2009 - 00: 00Z (meia-noite no início de 1970 GMT / UTC).
A classe equivalente a java.util.Date
no JSR-310 é Instant
, portanto, existe um método conveniente toInstant()
para fornecer a conversão:
Date input = new Date();
Instant instant = input.toInstant();
Uma java.util.Date
instâ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 Instant
também não contém nenhuma informação sobre o fuso horário. Assim, para converter de uma Instant
data para uma 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. Use o atZone()
método para aplicar o fuso horário:
Date input = new Date();
Instant instant = input.toInstant();
ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
A ZonedDateTime
contém o estado que consiste na data e hora locais, no fuso horário e no deslocamento de GMT / UTC. Como tal, a data - LocalDate
- pode ser facilmente extraída usando toLocalDate()
:
Date input = new Date();
Instant instant = input.toInstant();
ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
LocalDate date = zdt.toLocalDate();
Resposta Java 9
No Java SE 9, foi adicionado um novo método que simplifica levemente esta tarefa:
Date input = new Date();
LocalDate date = LocalDate.ofInstant(input.toInstant(), ZoneId.systemDefault());
Essa nova alternativa é mais direta, criando menos lixo e, portanto, deve ter um desempenho melhor.
Date
não tem conceito de fuso horário, Instant
também não contém informações sobre fuso horário. A LocalDate
API diz "Uma data sem fuso horário". Então, por que converter de Date
para Instant
em LocalDate
necessidades atZone(ZoneId.systemDefault())
?
LocalDate
e LocalDateTime
não "armazena ou representa uma hora ou um fuso horário" (ref: javadocs). Enquanto eles não o armazenam - as classes representam uma Local
data e / ou hora, portanto, a conversão para data / hora local implica um fuso horário.
Melhor maneira é:
Date date = ...;
Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()).toLocalDate()
Vantagens desta versão:
funciona independentemente da entrada ser uma instância java.util.Date
ou subclasse de java.sql.Date
(diferente da maneira de @ JodaStephen). Isso é comum com dados originados por JDBC. java.sql.Date.toInstant()
sempre lança uma exceção.
é o mesmo para o JDK8 e o JDK7 com backport JSR-310
Eu pessoalmente uso uma classe de utilitário (mas não é compatível com 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);
}
}
O asLocalDate()
método aqui é seguro para nulos, usa toLocalDate()
, se a entrada for java.sql.Date
(pode ser substituída pelo driver JDBC para evitar problemas de fuso horário ou cálculos desnecessários), caso contrário, usa o método mencionado acima.
DateConvertUtils
.
Date.toInstant()
.
LocalDate localDate = LocalDate.parse( new SimpleDateFormat("yyyy-MM-dd").format(date) );
SimpleDateFormat
instância está confinada ao encadeamento atual. É usado de maneira segura para threads. Agora, SimpleDateFormat
tem a fama de ser 'caro para instanciar' (por conta de todas as estruturas de dados internas de que necessita), mas você não pode compartilhar um como um 'solteirão' (sem sincronizar o acesso a ele), porque ele na verdade não é thread- seguro. (Uma ThreadLocal
solução pode funcionar se o código 'poluente') Thread
for responsável pelo ciclo de vida do encadeamento ... mas isso raramente acontece). Desajeitado. Evitar SimpleDateFormat
é o motivo do uso javax.time
.
SimpleDateFormat
(que é jogada fora), a cadeia intermediária (que é jogada fora) e o custo da análise. É uma solução, mas não é recomendado.
Se você estiver usando o Java 8, a resposta do @ JodaStephen é obviamente a melhor. No entanto, se você estiver trabalhando com o backport JSR-310 , infelizmente precisará fazer algo assim:
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();
Você pode converter em uma linha:
public static LocalDate getLocalDateFromDate(Date date){
return LocalDate.from(Instant.ofEpochMilli(date.getTime()).atZone(ZoneId.systemDefault()));
}
primeiro, é fácil converter uma data em um instante
Instant timestamp = new Date().toInstant();
Em seguida, você pode converter a API do Instant para qualquer data no jdk 8 usando o método ofInstant ():
LocalDateTime date = LocalDateTime.ofInstant(timestamp, ZoneId.systemDefault());
import java.sql.Date
em seu arquivo: o toInstant()
método de java.sql.Date
sempre lança.
Date input = new Date();
LocalDateTime conv=LocalDateTime.ofInstant(input.toInstant(), ZoneId.systemDefault());
LocalDate convDate=conv.toLocalDate();
A Date
instância contém tempo também, juntamente com a data, enquanto LocalDate
não. Portanto, você pode convertê-lo primeiro em LocalDateTime
usar seu método ofInstant()
e, se desejar, sem tempo, em seguida, converter a instância em LocalDate
.
public static LocalDate Date2LocalDate(Date date) {
return LocalDate.parse(date.toString(), DateTimeFormatter.ofPattern("EEE MMM dd HH:mm:ss zzz yyyy"))
esse formato é 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();
}
Eu tive problemas com a implementação do @ JodaStephen no JBoss EAP 6. Portanto, reescrevi a conversão seguindo o Tutorial Java do Oracle em 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();
O que há de errado com esta 1 linha simples?
new LocalDateTime(new Date().getTime()).toLocalDate();
Resolvi esta questão com a solução abaixo
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);
Nesse caso, localDate imprima sua data neste formato "aaaa-MM-dd"
java.time
classes no JDK8, não no Joda Time.
LocalDate.from(Instant.ofEpochMilli(date.getTime()))
acho que é equivalente ao seu, mas mais direto.