Tl; dr

Instant.now()   // Capture the current moment in UTC. 

Générez une chaîne pour représenter cette valeur:

Instant.now().toString()  

2016-09-13T23:30:52.123 Z

Détails

Comme la bonne réponse de Jon Skeet a déclaré, un java.util.L'objet Date n'a aucun fuseau horaire^†. Mais son toString l'implémentation applique le fuseau horaire par défaut de la JVM lors de la génération de la représentation de chaîne de cette valeur date-heure. Confusément au programmeur naïf, une date semble avoir un fuseau horaire mais pas.

Le java.util.Date, j.u.Calendar, et java.text.SimpleDateFormat les classes fournies avec Java sont notoirement gênantes. Évitez-les. Au lieu de cela, utilisez l'une de ces bibliothèques date-heure compétentes:

• java.temps.* paquet en Java 8
• Joda-Temps

Java.temps (Java 8)

Java 8 apporte une excellente nouvelle java.temps.* paquet pour remplacer l'ancien Java.util.Classes de date/Calendrier.

Obtenir l'heure actuelle en UTC / GMT est un simple one-liner {

Instant instant = Instant.now();

, ce Qui Instant la classe est le bloc de construction de base en java.temps, représentant un moment sur la timeline en UTC avec une résolution de nanosecondes .

Dans Java 8, le moment actuel est capturé avec une résolution allant jusqu'à quelques millisecondes. Java 9) apporte une nouvelle mise en œuvre de Clock capture le moment actuel dans jusqu' à la capacité nanoseconde complète de cette classe, en fonction de la capacité du matériel d'horloge de votre ordinateur hôte.

Sa méthode toStringgénère une représentation de chaîne de sa valeur en utilisant un format ISO 8601 spécifique. Ce format sorties zéro, trois, six ou neuf chiffres chiffres (millisecondes, microsecondes, ou nanosecondes) comme nécessaire pour représenter la fraction de seconde.

Si vous voulez un formatage plus flexible, ou autre fonctionnalités supplémentaires, puis appliquez un décalage par rapport à UTC de zéro, pour UTC lui-même (ZoneOffset.UTC constante ) pour obtenir un OffsetDateTime.

OffsetDateTime now = OffsetDateTime.now( ZoneOffset.UTC );

Vidage sur console {

System.out.println( "now.toString(): " + now );

Lors de l'exécution...

now.toString(): 2014-01-21T23:42:03.522Z

À propos de java.temps

Le java.temps framework est intégré à Java 8 et versions ultérieures. Ces classes supplantent les anciennes héritées classes date-heure gênantes telles que java.util.Date, Calendar, & SimpleDateFormat.

Pour en savoir plus, voir le Tutoriel Oracle. Et rechercher Stack Overflow pour de nombreux exemples et explications. La spécification est JSR 310.

Le Joda-Temps le projet, maintenant en mode de maintenance, conseille la migration vers le java.temps classes.

, Vous pouvez échanger java.temps objets directement avec votre base de données. Utiliser un pilote JDBC compatible avec JDBC 4.2 ou version ultérieure. Pas besoin de chaînes, pas besoin de classes java.sql.*.

Où obtenir le java.les classes de temps?

• Java SE 8, Java SE 9, Java SE 10, Java SE 11, et plus tard Partie de la norme API Java avec une liasse de mise en œuvre.
  • Java 9 ajoute quelques fonctionnalités et corrections mineures.
• Java SE 6 et Java SE 7
  • la Plupart des java.temps fonctionnalité est porté à Java 6 et 7ThreeTen-Backport.
• Android
  Les versions ultérieures des implémentations de bundle Android du java.temps classes.
• Pour Android antérieur (Troisabp le projet s'adapte ThreeTen-Backport (mentionné ci-dessus). Voir Comment utiliser ThreeTenABP....

Le Trois-Extra le projet étend java.temps avec des cours supplémentaires. Ce projet est un terrain d'essai pour d'éventuels ajouts futurs à java.temps. Vous pouvez trouver quelques classes utiles ici comme Interval, YearWeek, YearQuarter, et plus.

Joda-Temps

MISE À JOUR: Le projetJoda-Time , maintenant en modemaintenance , conseille la migration vers le java.temps classes.

En utilisant la bibliothèque open source gratuiteJoda-Time 3rd-party, vous pouvez obtenir la date-heure actuelle en une seule ligne de code.

Joda-Le temps a inspiré le nouveau java.temps.* classes en Java 8, mais a une architecture différente. Vous pouvez utiliser Joda-Time dans les anciennes versions de Java. Joda-Time continue de fonctionner en Java 8 et continue d'être activement maintenu (à partir de 2014). Cependant, l'équipe Joda-Time conseille la migration vers java.temps.

System.out.println( "UTC/GMT date-time in ISO 8601 format: " + new org.joda.time.DateTime( org.joda.time.DateTimeZone.UTC ) );

Exemple de code plus détaillé (Joda-Time 2.3) {

org.joda.time.DateTime now = new org.joda.time.DateTime(); // Default time zone.
org.joda.time.DateTime zulu = now.toDateTime( org.joda.time.DateTimeZone.UTC );

Vidage sur console {

System.out.println( "Local time in ISO 8601 format: " + now );
System.out.println( "Same moment in UTC (Zulu): " + zulu );

Lors de l'exécution...

Local time in ISO 8601 format: 2014-01-21T15:34:29.933-08:00
Same moment in UTC (Zulu): 2014-01-21T23:34:29.933Z

Pour plus d'exemple de code faisant le travail de fuseau horaire, voir ma réponse à une question similaire.

Fuseau horaire

Je vous recommande de toujours spécifier un fuseau horaire plutôt que s'appuyant implicitement sur le fuseau horaire actuel par défaut de la JVM (qui peut changer à tout moment!). Une telle confiance semble être une cause fréquente de confusion et de bugs dans le travail date-heure.

Lorsque vous appelez now() passez le fuseau horaire souhaité/attendu à attribuer. L'utilisation de la DateTimeZone classe.

DateTimeZone zoneMontréal = DateTimeZone.forID( "America/Montreal" );
DateTime now = DateTime.now( zoneMontréal );

Cette classe contient une constante pour le fuseau horaire UTC.

DateTime now = DateTime.now( DateTimeZone.UTC );

Si vous voulez vraiment utiliser le fuseau horaire par défaut actuel de la JVM, faites un appel explicite pour que votre code soit l'auto-documentation.

DateTimeZone zoneDefault = DateTimeZone.getDefault();

ISO 8601

Lisez à propos des formats ISO 8601. Les deux java.time et Joda-Time utilisent les formats sensibles de cette norme comme valeurs par défaut pour l'analyse et la génération de chaînes.

^† en Fait, java.util.Date a-t-il un fuseau horaire, enfoui profondément sous des couches de code source. Pour la plupart des raisons pratiques, ce fuseau horaire est ignoré. Donc, comme raccourci, nous disons java.util.La date n'a pas de fuseau horaire. En outre, que le fuseau horaire enterré est et non celui utilisé par la méthode Date toString; cette méthode utilise le fuseau horaire par défaut actuel de la JVM. Raison de plus pour éviter cette classe confuse et rester avec Joda-Time et java.temps.

SimpleDateFormat dateFormatGmt = new SimpleDateFormat("yyyy-MMM-dd HH:mm:ss");
dateFormatGmt.setTimeZone(TimeZone.getTimeZone("GMT"));

//Local time zone   
SimpleDateFormat dateFormatLocal = new SimpleDateFormat("yyyy-MMM-dd HH:mm:ss");

//Time in GMT
return dateFormatLocal.parse( dateFormatGmt.format(new Date()) );

Cela renvoie définitivement UTC time: en tant qu'objets String et Date !

static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

public static Date getUTCdatetimeAsDate() {
    // note: doesn't check for null
    return stringDateToDate(getUTCdatetimeAsString());
}

public static String getUTCdatetimeAsString() {
    final SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    final String utcTime = sdf.format(new Date());

    return utcTime;
}

public static Date stringDateToDate(String StrDate) {
    Date dateToReturn = null;
    SimpleDateFormat dateFormat = new SimpleDateFormat(DATEFORMAT);

    try {
        dateToReturn = (Date)dateFormat.parse(StrDate);
    }
    catch (ParseException e) {
        e.printStackTrace();
    }

    return dateToReturn;
}

    Calendar c = Calendar.getInstance();
    System.out.println("current: "+c.getTime());

    TimeZone z = c.getTimeZone();
    int offset = z.getRawOffset();
    if(z.inDaylightTime(new Date())){
        offset = offset + z.getDSTSavings();
    }
    int offsetHrs = offset / 1000 / 60 / 60;
    int offsetMins = offset / 1000 / 60 % 60;

    System.out.println("offset: " + offsetHrs);
    System.out.println("offset: " + offsetMins);

    c.add(Calendar.HOUR_OF_DAY, (-offsetHrs));
    c.add(Calendar.MINUTE, (-offsetMins));

    System.out.println("GMT Time: "+c.getTime());

En fait pas le temps, mais sa représentation pourrait être modifiée.

SimpleDateFormat f = new SimpleDateFormat("yyyy-MMM-dd HH:mm:ss");
f.setTimeZone(TimeZone.getTimeZone("UTC"));
System.out.println(f.format(new Date()));

Le temps est le même en tout point de la Terre, mais notre perception du temps pourrait être différente selon l'emplacement.

Calendrier aGMTCalendar = Calendrier.getInstance (fuseau horaire.getTimeZone ("GMT")); Ensuite, toutes les opérations effectuées à l'aide de l'objet aGMTCalendar seront effectuées avec le fuseau horaire GMT et l'heure d'été ou les décalages fixes ne seront pas appliqués

Faux!

Calendar aGMTCalendar = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
aGMTCalendar.getTime(); //or getTimeInMillis()

Et

Calendar aNotGMTCalendar = Calendar.getInstance(TimeZone.getTimeZone("GMT-2"));aNotGMTCalendar.getTime();

Retournera en même temps. Idem pour

new Date(); //it's not GMT.

Cela fonctionne pour obtenir des millisecondes UTC dans Android.

Calendar c = Calendar.getInstance();
int utcOffset = c.get(Calendar.ZONE_OFFSET) + c.get(Calendar.DST_OFFSET);  
Long utcMilliseconds = c.getTimeInMillis() + utcOffset;

Ce code affiche l'heure actuelle UTC.

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;


public class Test
{
    public static void main(final String[] args) throws ParseException
    {
        final SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");
        f.setTimeZone(TimeZone.getTimeZone("UTC"));
        System.out.println(f.format(new Date()));
    }
}

Résultat

2013-10-26 14:37:48 UTC

Voici ce qui semble être incorrect dans La réponse de Jon Skeet. Il a dit:

java.util.Date est toujours en UTC. Ce qui vous fait penser que c'est en local de temps? Je soupçonne que le problème est que vous l'affichez via un instance de Calendar qui utilise le fuseau horaire local, ou éventuellement en utilisant Date.toString(), qui utilise également le fuseau horaire local.

Cependant, le code:

System.out.println(new java.util.Date().getHours() + " hours");

Donne les heures locales, pas GMT( heures UTC), en utilisant no Calendar et no SimpleDateFormat à tout.

C'est pourquoi il semble que quelque chose soit incorrect.

En rassemblant les réponses, le code:

System.out.println(Calendar.getInstance(TimeZone.getTimeZone("GMT"))
                           .get(Calendar.HOUR_OF_DAY) + " Hours");

Affiche les heures GMT au lieu des heures locales note notez que getTime.getHours() est manquant car cela créerait un objet Date(), qui stocke théoriquement la date en GMT, mais restitue les heures dans le fuseau horaire local.

Vous pouvez utiliser:

Calendar aGMTCalendar = Calendar.getInstance(TimeZone.getTimeZone("GMT"));

Ensuite, toutes les opérations effectuées à l'aide de l'objet aGMTCalendar seront effectuées avec le fuseau horaire GMT et l'heure d'été ou les décalages fixes ne seront pas appliqués. Je pense que l'affiche précédente est correcte que l'objet Date() renvoie toujours un GMT ce n'est que lorsque vous allez faire quelque chose avec l'objet date qu'il est converti en fuseau horaire local.

Si vous voulez un objet Date avec des champs ajustés pour UTC, vous pouvez le faire comme ceci avec Joda Time :

import org.joda.time.DateTimeZone;
import java.util.Date;

...

Date local = new Date();
System.out.println("Local: " + local);
DateTimeZone zone = DateTimeZone.getDefault();
long utc = zone.convertLocalToUTC(local.getTime(), false);
System.out.println("UTC: " + new Date(utc));

SimpleDateFormat dateFormatGmt = new SimpleDateFormat("yyyy-MM-dd");
dateFormatGmt.setTimeZone(TimeZone.getTimeZone("GMT"));
System.out.println(dateFormatGmt.format(date));

Voici mon implémentation de toUTC:

    public static Date toUTC(Date date){
    long datems = date.getTime();
    long timezoneoffset = TimeZone.getDefault().getOffset(datems);
    datems -= timezoneoffset;
    return new Date(datems);
}

Il y a probablement plusieurs façons de l'améliorer, mais cela fonctionne pour moi.

, Vous pouvez directement utiliser ce

SimpleDateFormat dateFormatGmt = new SimpleDateFormat("dd:MM:yyyy HH:mm:ss");
dateFormatGmt.setTimeZone(TimeZone.getTimeZone("GMT"));
System.out.println(dateFormatGmt.format(new Date())+"");

Avec:

Calendar cal = Calendar.getInstance();

Puis cal ont la date et l'heure actuelles.
Vous pouvez également obtenir la date et l'heure actuelles pour le fuseau horaire avec:

Calendar cal2 = Calendar.getInstance(TimeZone.getTimeZone("GMT-2"));

Vous pouvez demander cal.get(Calendar.DATE); ou une autre constante de calendrier sur les autres détails.
La date et l'horodatage sont obsolètes en Java. Classe de calendrier ce n'est pas le cas.

Voici une autre suggestion pour obtenir un objet horodatage GMT:

import java.sql.Timestamp;
import java.util.Calendar;

...

private static Timestamp getGMT() {
   Calendar cal = Calendar.getInstance();
   return new Timestamp(cal.getTimeInMillis()
                       -cal.get(Calendar.ZONE_OFFSET)
                       -cal.get(Calendar.DST_OFFSET));
}

Voici une autre façon d'obtenir l'heure GMT au format Chaîne

String DATE_FORMAT = "EEE, dd MMM yyyy HH:mm:ss z" ;
final SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
String dateTimeString =  sdf.format(new Date());

Exemple de code pour rendre l'heure du système dans un fuseau horaire spécifique et un format spécifique.

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

public class TimZoneTest {
    public static void main (String[] args){
        //<GMT><+/-><hour>:<minutes>
        // Any screw up in this format, timezone defaults to GMT QUIETLY. So test your format a few times.

        System.out.println(my_time_in("GMT-5:00", "MM/dd/yyyy HH:mm:ss") );
        System.out.println(my_time_in("GMT+5:30", "'at' HH:mm a z 'on' MM/dd/yyyy"));

        System.out.println("---------------------------------------------");
        // Alternate format 
        System.out.println(my_time_in("America/Los_Angeles", "'at' HH:mm a z 'on' MM/dd/yyyy") );
        System.out.println(my_time_in("America/Buenos_Aires", "'at' HH:mm a z 'on' MM/dd/yyyy") );


    }

    public static String my_time_in(String target_time_zone, String format){
        TimeZone tz = TimeZone.getTimeZone(target_time_zone);
        Date date = Calendar.getInstance().getTime();
        SimpleDateFormat date_format_gmt = new SimpleDateFormat(format);
        date_format_gmt.setTimeZone(tz);
        return date_format_gmt.format(date);
    }

}

Sortie

10/08/2011 21:07:21
at 07:37 AM GMT+05:30 on 10/09/2011
at 19:07 PM PDT on 10/08/2011
at 23:07 PM ART on 10/08/2011

Juste pour que cela soit plus simple, pour créer un Date dans UTC vous pouvez utiliser Calendar :

Calendar.getInstance(TimeZone.getTimeZone("UTC"));

Qui construira une nouvelle instance pour Calendar en utilisant le "UTC" TimeZone.

Si vous avez besoin d'un Date objet de ce calendrier vous pouvez simplement utiliser getTime().

Conversion du DateTime actuel en UTC:

DateTimeFormatter formatter = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");

DateTimeZone dateTimeZone = DateTimeZone.getDefault(); //Default Time Zone

DateTime currDateTime = new DateTime(); //Current DateTime

long utcTime = dateTimeZone.convertLocalToUTC(currDateTime .getMillis(), false);

String currTime = formatter.print(utcTime); //UTC time converted to string from long in format of formatter

currDateTime = formatter.parseDateTime(currTime); //Converted to DateTime in UTC

Cela a fonctionné pour moi, renvoie l'horodatage en GMT!

    Date currDate;
    SimpleDateFormat dateFormatGmt = new SimpleDateFormat("yyyy-MMM-dd HH:mm:ss");
    dateFormatGmt.setTimeZone(TimeZone.getTimeZone("GMT"));
    SimpleDateFormat dateFormatLocal = new SimpleDateFormat("yyyy-MMM-dd HH:mm:ss");

    long currTime = 0;
    try {

        currDate = dateFormatLocal.parse( dateFormatGmt.format(new Date()) );
        currTime = currDate.getTime();
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

Utilisez cette classe pour obtenir la bonne heure UTC à partir d'un serveur NTP en ligne:

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;


class NTP_UTC_Time
{
private static final String TAG = "SntpClient";

private static final int RECEIVE_TIME_OFFSET = 32;
private static final int TRANSMIT_TIME_OFFSET = 40;
private static final int NTP_PACKET_SIZE = 48;

private static final int NTP_PORT = 123;
private static final int NTP_MODE_CLIENT = 3;
private static final int NTP_VERSION = 3;

// Number of seconds between Jan 1, 1900 and Jan 1, 1970
// 70 years plus 17 leap days
private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L;

private long mNtpTime;

public boolean requestTime(String host, int timeout) {
    try {
        DatagramSocket socket = new DatagramSocket();
        socket.setSoTimeout(timeout);
        InetAddress address = InetAddress.getByName(host);
        byte[] buffer = new byte[NTP_PACKET_SIZE];
        DatagramPacket request = new DatagramPacket(buffer, buffer.length, address, NTP_PORT);

        buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3);

        writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET);

        socket.send(request);

        // read the response
        DatagramPacket response = new DatagramPacket(buffer, buffer.length);
        socket.receive(response);          
        socket.close();

        mNtpTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);            
    } catch (Exception e) {
      //  if (Config.LOGD) Log.d(TAG, "request time failed: " + e);
        return false;
    }

    return true;
}


public long getNtpTime() {
    return mNtpTime;
}


/**
 * Reads an unsigned 32 bit big endian number from the given offset in the buffer.
 */
private long read32(byte[] buffer, int offset) {
    byte b0 = buffer[offset];
    byte b1 = buffer[offset+1];
    byte b2 = buffer[offset+2];
    byte b3 = buffer[offset+3];

    // convert signed bytes to unsigned values
    int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);
    int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);
    int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);
    int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);

    return ((long)i0 << 24) + ((long)i1 << 16) + ((long)i2 << 8) + (long)i3;
}

/**
 * Reads the NTP time stamp at the given offset in the buffer and returns 
 * it as a system time (milliseconds since January 1, 1970).
 */    
private long readTimeStamp(byte[] buffer, int offset) {
    long seconds = read32(buffer, offset);
    long fraction = read32(buffer, offset + 4);
    return ((seconds - OFFSET_1900_TO_1970) * 1000) + ((fraction * 1000L) / 0x100000000L);        
}

/**
 * Writes 0 as NTP starttime stamp in the buffer. --> Then NTP returns Time OFFSET since 1900
 */    
private void writeTimeStamp(byte[] buffer, int offset) {        
    int ofs =  offset++;

    for (int i=ofs;i<(ofs+8);i++)
      buffer[i] = (byte)(0);             
}

}

Et l'utiliser avec:

        long now = 0;

        NTP_UTC_Time client = new NTP_UTC_Time();

        if (client.requestTime("pool.ntp.org", 2000)) {              
          now = client.getNtpTime();
        }

Si vous avez besoin de l'heure UTC "maintenant" comme DateTimeString, utilisez la fonction:

private String get_UTC_Datetime_from_timestamp(long timeStamp){

    try{

        Calendar cal = Calendar.getInstance();
        TimeZone tz = cal.getTimeZone();

        int tzt = tz.getOffset(System.currentTimeMillis());

        timeStamp -= tzt;

        // DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.getDefault());
        DateFormat sdf = new SimpleDateFormat();
        Date netDate = (new Date(timeStamp));
        return sdf.format(netDate);
    }
    catch(Exception ex){
        return "";
     }
    } 

Et l'utiliser avec:

String UTC_DateTime = get_UTC_Datetime_from_timestamp(now);

public static void main(String args[]){
    LocalDate date=LocalDate.now();  
    System.out.println("Current date = "+date);
}

Pour faire simple. Un objet calendrier stocke des informations sur le fuseau horaire mais lorsque vous effectuez cal.getTime() alors les informations du fuseau horaire seront perdues. Donc, pour les conversions de fuseau horaire, je conseillerai d'utiliser les classes DateFormat...

Ceci est mon implémentation:

public static String GetCurrentTimeStamp()
{
    Calendar cal=Calendar.getInstance();
    long offset = cal.getTimeZone().getOffset(System.currentTimeMillis());//if you want in UTC else remove it .
    return new java.sql.Timestamp(System.currentTimeMillis()+offset).toString();    
}

Si vous voulez éviter d'analyser la date et que vous voulez juste un horodatage en GMT, vous pouvez utiliser:

final Date gmt = new Timestamp(System.currentTimeMillis()
            - Calendar.getInstance().getTimeZone()
                    .getOffset(System.currentTimeMillis()));

public class CurrentUtcDate 
{
    public static void main(String[] args) {
        Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
        System.out.println("UTC Time is: " + dateFormat.format(date));
    }
}

Sortie:

UTC Time is: 22-01-2018 13:14:35

Vous pouvez modifier le format de la date si nécessaire.

Si vous utilisez joda temps et que vous voulez l'heure actuelle en millisecondes sans votre le décalage, vous pouvez utiliser ceci:

long instant = DateTimeZone.UTC.getMillisKeepLocal(DateTimeZone.getDefault(), System.currentTimeMillis());

Date actuelle dans l'UTC

Instant.now().toString().replaceAll("T.*", "");