Qual é a maneira mais elegante de obter a apresentação formatada em ISO 8601 do momento atual, UTC? Deve olhar como: 2010-10-12T08:50Z.

Exemplo:

String iso8601 = DateFormat.getDateTimeInstance(DateFormat.ISO_8601).format(date);

Use SimpleDateFormatpara formatar qualquer Dateobjeto que você deseja:

TimeZone tz = TimeZone.getTimeZone("UTC");
DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'"); // Quoted "Z" to indicate UTC, no timezone offset
df.setTimeZone(tz);
String nowAsISO = df.format(new Date());

Usar um new Date()como mostrado acima formatará a hora atual.

Para sistemas em que o fuso horário padrão não é UTC:

TimeZone tz = TimeZone.getTimeZone("UTC");
DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'");
df.setTimeZone(tz);
String nowAsISO = df.format(new Date());

A SimpleDateFormatinstância pode ser declarada como uma constante global, se necessário com freqüência, mas tome cuidado para que essa classe não seja segura para threads. Ele deve ser sincronizado se acessado simultaneamente por vários encadeamentos.

EDIT: Eu preferiria Joda Time se estivesse fazendo muitas manipulações diferentes de Data / Hora ...
EDIT2: corrigido: setTimeZonenão aceita uma String (corrigida por Paul)

Java 8 Native

O java.time simplifica desde o Java 8. E é seguro para threads.

ZonedDateTime.now( ZoneOffset.UTC ).format( DateTimeFormatter.ISO_INSTANT )

Resultado: 2015-04-14T11:07:36.639Z

Você pode ficar tentado a usar isqueiros Temporalcomo Instantou LocalDateTime, mas não possui suporte ao formatador ou dados de fuso horário. Só ZonedDateTimefunciona fora da caixa.

Ao ajustar ou encadear as opções / operações de ZonedDateTime e DateTimeFormatter , você pode controlar facilmente o fuso horário e a precisão , até um certo grau:

ZonedDateTime.now( ZoneId.of( "Europe/Paris" ) )
             .truncatedTo( ChronoUnit.MINUTES )
             .format( DateTimeFormatter.ISO_DATE_TIME )

Resultado: 2015-04-14T11:07:00+01:00[Europe/Paris]

Requisitos refinados, como a remoção da parte dos segundos, ainda devem ser atendidos por formatos personalizados ou pós-processamento personalizado.

.format( DateTimeFormatter.ISO_LOCAL_DATE_TIME ) // 2015-04-14T11:07:00
.format( DateTimeFormatter.ISO_LOCAL_DATE ) // 2015-04-14
.format( DateTimeFormatter.ISO_LOCAL_TIME ) // 11:07:00
.format( DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm" ) ) // 2015-04-14 11:07

Para Java 6 e 7, considere as portas traseiras do java.time, como o ThreeTen-Backport , que também possui uma porta Android . Ambos são mais leves que Joda e aprenderam com a experiência de Joda - esp. considerando que java.time foi desenvolvido pelo autor de Joda.

Java 8:

thisMoment = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mmX")
                              .withZone(ZoneOffset.UTC)
                              .format(Instant.now());

Antes do Java 8:

thisMoment = String.format("%tFT%<tRZ",
                           Calendar.getInstance(TimeZone.getTimeZone("Z")));

Dos documentos :

'R'    Hora formatada para o relógio de 24 horas como "% tH:% tM"
'F'    Data de conclusão ISO 8601 formatada como "% tY-% tm-% td".

No Java 8, você pode simplesmente fazer:

Instant.now().toString();

Dos java.time.Instantdocumentos:

agora

---

public static Instant now()

Obtém o instante atual do relógio do sistema.

Isso consultará o relógio UTC do sistema para obter o instante atual.

---

public String toString()

Uma representação em cadeia deste instante usando a representação ISO-8601.

O formato usado é o mesmo que DateTimeFormatter.ISO_INSTANT.

use JodaTime

O sistema de calendário ISO 8601 é a implementação padrão no Joda-Time

Aqui está o documento para o JodaTime Formatter

Editar:

Se você não deseja adicionar ou não vê o valor de adicionar a biblioteca acima, basta usar a SimpleDateFormatclasse construída para formatar a Data no formato ISO exigido

como sugerido por @Joachim Sauer

DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mmZ");
String nowAsString = df.format(new Date());

DateFormatUtils do Apache commons-lang3tem constantes úteis, por exemplo:DateFormatUtils.ISO_DATETIME_FORMAT

Se você não deseja incluir o Jodatime (por mais legal que seja)

javax.xml.bind.DatatypeConverter.printDateTime(
    Calendar.getInstance(TimeZone.getTimeZone("UTC"))
);

que retorna uma sequência de:

2012-07-10T16:02:48.440Z

que é um pouco diferente da solicitação original, mas ainda é ISO-8601.

A ISO 8601 pode conter segundos, consulte http://en.wikipedia.org/wiki/ISO_8601#Times

então o código deve ser

DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");

Joda-Time

Atualização: o projeto Joda-Time agora está no modo de manutenção , com a equipe aconselhando a migração para as classes java.time . Para Java 6 e 7, consulte o projeto ThreeTen-Backport , mais adaptado para Android no projeto ThreeTenABP .

Usando a biblioteca Joda-Time …

String output = new DateTime( DateTimeZone.UTC ).toString() ;

Isso é seguro para threads. O Joda-Time cria novos objetos imutáveis, em vez de alterar os objetos existentes.

Se você realmente pretendia solicitar um formato sem segundos, resolvendo para minutos, use um dos muitos outros formatadores incorporados no Joda-Time.

DateTime now = new DateTime( DateTimeZone.UTC ) ;
String output = ISODateTimeFormat.dateHourMinute.print( now ) ;

java.time

Para Java 8 e posterior, o Joda-Time continua funcionando. Mas a estrutura java.time integrada substitui o Joda-Time. Portanto, migre seu código do Joda-Time para java.time assim que for conveniente.

Veja minha outra resposta para uma solução moderna.

Sobre java.time

A estrutura java.time é integrada ao Java 8 e posterior. Essas classes suplantar os velhos problemáticos legados aulas de data e hora, como java.util.Date, Calendar, e SimpleDateFormat.

O projeto Joda-Time , agora em modo de manutenção , aconselha a migração para as classes java.time .

Para saber mais, consulte o Tutorial do Oracle . E procure Stack Overflow para muitos exemplos e explicações. A especificação é JSR 310 .

Você pode trocar objetos java.time diretamente com seu banco de dados. Use um driver JDBC compatível com JDBC 4.2 ou posterior. Não há necessidade de strings, não há necessidade de java.sql.*classes.

Onde obter as classes java.time?

• Java SE 8 , Java SE 9 , Java SE 10 e posterior
  • Construídas em.
  • Parte da API Java padrão com uma implementação em pacote configurável.
  • O Java 9 adiciona alguns recursos e correções menores.
• Java SE 6 e Java SE 7
  • Grande parte da funcionalidade java.time é portada para Java 6 e 7 no ThreeTen-Backport .
• Android
  • Versões posteriores das implementações de pacote configurável do Android das classes java.time.
  • Para anteriormente Android (<26), o ThreeTenABP projeto adapta ThreeTen-Backport (mencionados acima). Consulte Como usar o ThreeTenABP… .

O projeto ThreeTen-Extra estende java.time com classes adicionais. Este projeto é um campo de prova para possíveis adições futuras ao java.time. Você pode encontrar algumas classes úteis aqui, como Interval, YearWeek, YearQuarter, e mais .

Para Java versão 7

Você pode seguir a documentação do Oracle: http://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html

X - é usado para o fuso horário ISO 8601

TimeZone tz = TimeZone.getTimeZone("UTC");
DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssX");
df.setTimeZone(tz);
String nowAsISO = df.format(new Date());

System.out.println(nowAsISO);

DateFormat df1 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssX");
//nowAsISO = "2013-05-31T00:00:00Z";
Date finalResult = df1.parse(nowAsISO);

System.out.println(finalResult);

Você pode usar o SimpleDateFormat do Java com o seguinte padrão yyyy-MM-dd'T'HH:mm:ssXXXpara ISO 8601.

Código de exemplo: (lista todos os fusos horários disponíveis)

for (String timeZone : TimeZone.getAvailableIDs())
{
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    dateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
    String formatted = dateFormat.format(new Date());
    System.out.print(formatted);

    if (formatted.endsWith("Z"))
    {
        // These time zone's have offset of '0' from GMT.
        System.out.print("\t(" + timeZone + ")");
    }

    System.out.println();
}

Você poderia usar:

TimeZone.getDefault ()

para o fuso horário padrão da vm. Mais aqui

Você pode observar a data e hora de alguns fusos horários que terminam com 'Z'. Esses fusos horários foram deslocados em '0'relação ao GMT.

Mais informações podem ser encontradas aqui .

Eu acredito que a maneira mais fácil é primeiro ir para o instante e depois para string como:

String d = new Date().toInstant().toString();

O que resultará em:

2017-09-08T12:56:45.331Z

tl; dr

Algumas das outras respostas estão corretas ao recomendar as classes java.time , mas continuam usando comprimentos desnecessários para suas necessidades específicas.

Instant.now()                               // Capture the current moment in UTC with a resolution as fines nanoseconds but usually in microseconds or milliseconds.
       .truncatedTo( ChronoUnit.MINUTES )   // Lop off any seconds or fractional second, to get a value in whole minutes.
       .toString()                          // Generate a String in standard ISO 8601 format where a `T` separates the year-month-day from the hour-minute-second, and the `Z` on the end for “Zulu” means UTC.

2018-01-23T12: 34Z

Instant::toString

A jav.time.Instantclasse representa um momento no UTC, sempre no UTC.

Instant instant = Instant.now() ;

Instale o Adobe Flash Player no seu dispositivo

O Zfinal de sua sequência de exemplo 2010-10-12T08:50Zé pronunciado "Zulu" e significa UTC .

O formato desejado está em conformidade com a norma ISO 8601 . As classes java.time usam esses formatos padrão por padrão ao analisar / gerar strings. Portanto, não há necessidade de especificar um padrão de formatação. Basta ligar Instant::toStringcomo visto acima.

Se você deseja especificamente minutos inteiros sem segundo ou segundo fracionário, então trunque. Especifique uma unidade de tempo via ChronoUnitclasse.

Instant instant = Instant.now().truncatedTo( ChronoUnit.MINUTES ) ;
String output = instant.toString();  // Generate a `String` object in standard ISO 8601 format.

Sobre java.time

A estrutura java.time é integrada ao Java 8 e posterior. Essas classes substituem o antigo e problemático legado data e hora , comojava.util.Date, Calendar, e SimpleDateFormat.

o Jodaprojeto , agora em modo de manutenção , aconselha a migração para as classes java.time .

Para saber mais, consulte o Tutorial do Oracle . E procure Stack Overflow para muitos exemplos e explicações. A especificação é JSR 310 .

Você pode trocar java.time objetos diretamente com seu banco de dados. Use um driver JDBC compatível com JDBC 4.2 ou posterior. Não há necessidade de strings, não há necessidade de java.sql.*classes.

Onde obter as classes java.time?

• Java SE 8 , Java SE 9 , Java SE 10 e posterior
  • Construídas em.
  • Parte da API Java padrão com uma implementação em pacote configurável.
  • O Java 9 adiciona alguns recursos e correções menores.
• Java SE 6 e Java SE 7
  • Grande parte da funcionalidade java.time é portada para Java 6 e 7 no ThreeTen-Backport .
• Android
  • Versões posteriores das implementações de pacote configurável do Android das classes java.time.
  • Para anteriormente Android (<26), o ThreeTenABP projeto adapta ThreeTen-Backport (mencionados acima). Consulte Como usar o ThreeTenABP… .

O projeto ThreeTen-Extra estende java.time com classes adicionais. Este projeto é um campo de prova para possíveis adições futuras ao java.time. Você pode encontrar algumas classes úteis aqui, como Interval, YearWeek, YearQuarter, e mais .

Aqui está uma classe inteira otimizada para que invocar "now ()" não faça mais do que precisa.

public class Iso8601Util
{
    private static TimeZone tz = TimeZone.getTimeZone("UTC");
    private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'");

    static
    {
        df.setTimeZone(tz);
    }

    public static String now()
    {
        return df.format(new Date());
    }
}

private static String getCurrentDateIso()
{
    // Returns the current date with the same format as Javascript's new Date().toJSON(), ISO 8601
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US);
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    return dateFormat.format(new Date());
}

Ainda assim, o joda-time suporta apenas o formato estendido: "2015-12-09T00: 22: 42.930Z", não o básico: "20151209T002242.930Z" ... talvez seja melhor testar uma lista de formatos com o java SimpleDateFormat.

Eu fiz isso no Android usando o Calendar e SimpleDateFormat. O método a seguir retorna um calendário com o fuso horário "GMT" (este é o fuso horário universal). Em seguida, você pode usar a classe Calendar para definir a hora entre diferentes fusos horários, usando o método setTimeZone () da classe Calendar.

private static final String GMT = "GMT";
private static final String DATE_FORMAT_ISO = "yyyyMMdd'T'HHmmss";

public static Calendar isoToCalendar(final String inputDate) {
    Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone(GMT));
    try {
        SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT_ISO, Locale.US);
        dateFormat.setTimeZone(TimeZone.getTimeZone(GMT));
        Date date = dateFormat.parse(inputDate);
        calendar.setTime(date);
    } catch (ParseException e) {
        Log.e("TAG",e.getMessage());
    }
    return calendar;
}

LEMBRE-SE: A classe Date não sabe sobre a existência do fuso horário. Por esse motivo, se você depurar uma data, sempre verá a data do seu fuso horário atual.

Se você se preocupa com o desempenho, criei uma biblioteca que supera o analisador e o formatador Java padrão ao manipular com datas no formato ISO8601. As implementações do DatetimeProcessor são seguras para encadeamento e podem ser armazenadas em cache em um mapa simultâneo ou em campos estáticos.

<dependency>
  <groupId>com.axibase</groupId>
  <artifactId>date-processor</artifactId>
  <version>1.0.3</version>
</dependency>

import com.axibase.date.DatetimeProcessor;
import com.axibase.date.PatternResolver;
import org.junit.Before;
import org.junit.Test;

import java.time.Clock;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZoneOffset;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.Is.is;

public class DateFormatTest {
    private Clock clock;

    @Before
    public void prepare() {
        clock = Clock.fixed(Instant.ofEpochMilli(1571285405300L), ZoneId.of("Europe/Berlin"));
    }

    @Test
    public void testIsoMillis(){
        final DatetimeProcessor formatter = PatternResolver.createNewFormatter("iso");
        assertThat(formatter.print(clock.millis(), ZoneOffset.UTC), is("2019-10-17T04:10:05.300Z"));
    }

    @Test
    public void testIsoMillisLocalZone(){
        final DatetimeProcessor formatter = PatternResolver.createNewFormatter("iso");
        assertThat(formatter.print(clock.millis(), clock.getZone()), is("2019-10-17T06:10:05.300+02:00"));
    }

    @Test
    public void testIsoMinutes(){
        final DatetimeProcessor formatter = PatternResolver.createNewFormatter("yyyy-MM-ddTHH:mmXXX");
        assertThat(formatter.print(clock.millis(), ZoneOffset.UTC), is("2019-10-17T04:10Z"));
    }
}

Eles deveriam ter adicionado algum tipo de maneira simples de ir do Date para o Instant e também um método chamado toISO8601, que é o que muitas pessoas procuram. Como complemento para outras respostas, do formato java.util.Date para ISO 8601:

Instant.ofEpochMilli(date.getTime()).toString();

Não é realmente visível ao usar o preenchimento automático, mas java.time.Instant.toString():

Uma representação em cadeia deste instante usando ISO-8601

DateTimeFormatter.ISO_DATE_TIME
        .withZone(ZoneOffset.UTC)
        .format(yourDateObject.toInstant())

Experimente,

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSSSSSZ");
        String date=sdf.format (new Date() );

É para o formato ISO 8601