example - Convertir fecha de Java a cadena UTC

string to date java

Question

El método java.util.Date toString() muestra la fecha en la zona horaria local.

Existen varios escenarios comunes en los que queremos que los datos se impriman en UTC , incluidos los registros, la exportación de datos y la comunicación con programas externos.

• ¿Cuál es la mejor manera de crear una representación de cadena de java.util.Date en UTC?
• ¿Cómo reemplazar el formato toString() juDate, que no se puede ordenar (gracias, @JonSkeet!) Por un formato mejor?

Apéndice

Creo que la forma estándar de imprimir la fecha en un formato personalizado y una zona horaria es bastante tediosa:

final Date date = new Date();
final String ISO_FORMAT = "yyyy-MM-dd''T''HH:mm:ss.SSS zzz";
final SimpleDateFormat sdf = new SimpleDateFormat(ISO_FORMAT);
final TimeZone utc = TimeZone.getTimeZone("UTC");
sdf.setTimeZone(utc);
System.out.println(sdf.format(date));

Estaba buscando una sola línea como:

System.out.println(prettyPrint(date, "yyyy-MM-dd''T''HH:mm:ss.SSS zzz", "UTC"));

Answer 1

java.time

En Java 8 y versiones posteriores tenemos el nuevo paquete java.time incorporado ( Tutorial ). Inspirado por Joda-Time, definido por JSR 310, y ampliado por el proyecto ThreeTen-Extra .

La mejor solución es ordenar los objetos de fecha y hora en lugar de cadenas . Pero si tienes que trabajar en cadenas, sigue leyendo.

Un Instant representa un momento en la línea de tiempo, básicamente en UTC (consulte la documentación de la clase para obtener detalles precisos). La implementación de toString usa el formato DateTimeFormatter.ISO_INSTANT de forma predeterminada. Este formato incluye dígitos de cero, tres, seis o nueve dígitos según sea necesario para mostrar una fracción de segundo hasta una precisión de nanosecond .

String output = Instant.now().toString(); // Example: ''2015-12-03T10:15:30.120Z''

Si debe interoperar con la clase Date , convierta a / desde java.time a través de los nuevos métodos agregados a las clases anteriores. Ejemplo: Date::toInstant .

myJavaUtilDate.toInstant().toString()

Es posible que desee utilizar un formateador alternativo si necesita un número constante de dígitos en el segundo fraccionario o si no necesita un segundo fraccionario.

Otra ruta si desea truncar fracciones de segundo es usar ZonedDateTime lugar de Instant , llamando a su método para cambiar la fracción a cero .

Tenga en cuenta que debemos especificar una zona horaria para ZonedDateTime (de ZonedDateTime el nombre). En nuestro caso eso significa UTC. La subclase de ZoneID , ZoneOffset , contiene una constante conveniente para UTC . Si omitimos la zona horaria, la zona horaria predeterminada actual de la JVM se aplica implícitamente.

String output = ZonedDateTime.now( ZoneOffset.UTC ).withNano( 0 ).toString(); // Example: 2015-08-27T19:28:58Z

Tiempo de joda

ACTUALIZACIÓN: El proyecto Joda-Time ahora está en modo de mantenimiento, con el equipo que aconseja la migración a las clases java.time.

Estaba buscando una sola línea

Fácil si usas la biblioteca Joda-Time 2.3. ISO 8601 es el formato predeterminado.

Zona horaria

En el ejemplo de código a continuación, tenga en cuenta que estoy especificando una zona horaria en lugar de depender de la zona horaria predeterminada. En este caso, estoy especificando UTC por su pregunta. La Z en el extremo, hablada como "Zulú", significa que no hay desplazamiento de zona horaria desde UTC.

Código de ejemplo

// import org.joda.time.*;
String output = new DateTime( DateTimeZone.UTC );

Salida…

2013-12-12T18:29:50.588Z

Answer 2

java.time.Instante

Solo usa Instant of java.time .

 System.out.println(Instant.now());

Esto acaba de imprimir:

2018-01-27T09:35:23.179612Z

Instant.toString siempre da la hora UTC.

La salida suele ser ordenable, pero hay excepciones desafortunadas. toString te da suficientes grupos de tres decimales para representar la precisión que tiene. En el Java 9 en mi Mac, la precisión de Instant.now() parece ser de microsegundos, pero debemos esperar que en aproximadamente un caso de cada mil alcanzará una cantidad de milisegundos e imprimirá solo tres decimales. Las cadenas con números desiguales de decimales se ordenarán en el orden incorrecto (a menos que escriba un comparador personalizado para tener esto en cuenta).

Instant es una de las clases en java.time , la moderna API de fecha y hora de Java, que recomiendo encarecidamente que utilice en lugar de la clase de Date obsoleta. java.time está integrado en Java 8 y java.time posteriores, y también se ha implementado en Java 6 y 7.

Answer 3

¿Por qué no usar java.text.SimpleDateFormat?

Date someDate = new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
String s = df.format(someDate);

O vea: http://www.tutorialspoint.com/java/java_date_time.htm

Answer 4

Bueno, si quieres usar java.util.Date solamente, aquí hay un pequeño truco que puedes usar:

String dateString = Long.toString (Date.UTC (date.getYear (), date.getMonth (), date.getDate (), date.getHours (), date.getMinutes (), date.getSeconds ())));

Answer 5

El siguiente código simplificado, basado en share , funcionó para mí:

public class GetSync {
public static String ISO_FORMAT = "yyyy-MM-dd''T''HH:mm:ss.SSS zzz";
private static final TimeZone utc = TimeZone.getTimeZone("UTC");
private static final SimpleDateFormat isoFormatter = new SimpleDateFormat(ISO_FORMAT);
static {
isoFormatter.setTimeZone(utc);
}
public static String now() {
return isoFormatter.format(new Date()).toString();
}
}

Espero que esto ayude a alguien.

Answer 6

Si XStream es una dependencia, intente:

new com.thoughtworks.xstream.converters.basic.DateConverter().toString(date)

Answer 7

Siguiendo los comentarios útiles, he reconstruido completamente el formateador de fecha. Se supone que el uso:

• Sea corto (un forro)
• Representar objetos desechables (zona horaria, formato) como cadenas
• Admite formatos ISO útiles y ordenados y el formato heredado de la caja.

Si considera que este código es útil, puedo publicar la fuente y un JAR en github.

Uso

// The problem - not UTC
Date.toString()
"Tue Jul 03 14:54:24 IDT 2012"
// ISO format, now
PrettyDate.now()
"2012-07-03T11:54:24.256 UTC"
// ISO format, specific date
PrettyDate.toString(new Date())
"2012-07-03T11:54:24.256 UTC"
// Legacy format, specific date
PrettyDate.toLegacyString(new Date())
"Tue Jul 03 11:54:24 UTC 2012"
// ISO, specific date and time zone
PrettyDate.toString(moonLandingDate, "yyyy-MM-dd hh:mm:ss zzz", "CST")
"1969-07-20 03:17:40 CDT"
// Specific format and date
PrettyDate.toString(moonLandingDate, "yyyy-MM-dd")
"1969-07-20"
// ISO, specific date
PrettyDate.toString(moonLandingDate)
"1969-07-20T20:17:40.234 UTC"
// Legacy, specific date
PrettyDate.toLegacyString(moonLandingDate)
"Wed Jul 20 08:17:40 UTC 1969"

Código

(Este código también es el tema de una pregunta en Code Review stackexchange )

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
/**
* Formats dates to sortable UTC strings in compliance with ISO-8601.
*
* @author Adam Matan <[email protected]>
* @see http://.com/questions/11294307/convert-java-date-to-utc-string/11294308
*/
public class PrettyDate {
public static String ISO_FORMAT = "yyyy-MM-dd''T''HH:mm:ss.SSS zzz";
public static String LEGACY_FORMAT = "EEE MMM dd hh:mm:ss zzz yyyy";
private static final TimeZone utc = TimeZone.getTimeZone("UTC");
private static final SimpleDateFormat legacyFormatter = new SimpleDateFormat(LEGACY_FORMAT);
private static final SimpleDateFormat isoFormatter = new SimpleDateFormat(ISO_FORMAT);
static {
legacyFormatter.setTimeZone(utc);
isoFormatter.setTimeZone(utc);
}
/**
* Formats the current time in a sortable ISO-8601 UTC format.
*
* @return Current time in ISO-8601 format, e.g. :
* "2012-07-03T07:59:09.206 UTC"
*/
public static String now() {
return PrettyDate.toString(new Date());
}
/**
* Formats a given date in a sortable ISO-8601 UTC format.
*
* <pre>
* <code>
* final Calendar moonLandingCalendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
* moonLandingCalendar.set(1969, 7, 20, 20, 18, 0);
* final Date moonLandingDate = moonLandingCalendar.getTime();
* System.out.println("UTCDate.toString moon: " + PrettyDate.toString(moonLandingDate));
* >>> UTCDate.toString moon: 1969-08-20T20:18:00.209 UTC
* </code>
* </pre>
*
* @param date
* Valid Date object.
* @return The given date in ISO-8601 format.
*
*/
public static String toString(final Date date) {
return isoFormatter.format(date);
}
/**
* Formats a given date in the standard Java Date.toString(), using UTC
* instead of locale time zone.
*
* <pre>
* <code>
* System.out.println(UTCDate.toLegacyString(new Date()));
* >>> "Tue Jul 03 07:33:57 UTC 2012"
* </code>
* </pre>
*
* @param date
* Valid Date object.
* @return The given date in Legacy Date.toString() format, e.g.
* "Tue Jul 03 09:34:17 IDT 2012"
*/
public static String toLegacyString(final Date date) {
return legacyFormatter.format(date);
}
/**
* Formats a date in any given format at UTC.
*
* <pre>
* <code>
* final Calendar moonLandingCalendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
* moonLandingCalendar.set(1969, 7, 20, 20, 17, 40);
* final Date moonLandingDate = moonLandingCalendar.getTime();
* PrettyDate.toString(moonLandingDate, "yyyy-MM-dd")
* >>> "1969-08-20"
* </code>
* </pre>
*
*
* @param date
* Valid Date object.
* @param format
* String representation of the format, e.g. "yyyy-MM-dd"
* @return The given date formatted in the given format.
*/
public static String toString(final Date date, final String format) {
return toString(date, format, "UTC");
}
/**
* Formats a date at any given format String, at any given Timezone String.
*
*
* @param date
* Valid Date object
* @param format
* String representation of the format, e.g. "yyyy-MM-dd HH:mm"
* @param timezone
* String representation of the time zone, e.g. "CST"
* @return The formatted date in the given time zone.
*/
public static String toString(final Date date, final String format, final String timezone) {
final TimeZone tz = TimeZone.getTimeZone(timezone);
final SimpleDateFormat formatter = new SimpleDateFormat(format);
formatter.setTimeZone(tz);
return formatter.format(date);
}
}