새 Date객체를 만들면 현재 시간으로 현지 시간대로 초기화됩니다. GMT에서 현재 날짜와 시간을 어떻게 알 수 있습니까?

java.util.DateUTC와 관련하여 가장 일반적으로 생각되지만 특정 시간대는 없습니다. 그것이 현지 시간이라고 생각하는 이유는 무엇입니까?

정확히 말하면 a 내의 값 java.util.Date은 UTC 1970 년 1 월 1 일 자정에 발생한 유닉스 시대 이후의 밀리 초입니다. 동일한 시간대는 다른 시간대에서도 설명 할 수 있지만 일반적인 설명은 UTC를 기준으로합니다. 고정 된 에포크 (epoch) 이후 수 밀리 초이므로java.util.Date 현지 시간대와 상관없이 특정 순간에 전세계 이 동일합니다.

문제는 현지 시간대를 사용하는 캘린더 인스턴스를 사용하거나 현지 시간대를 사용하는 캘린더 인스턴스를 통해 Date.toString()또는SimpleDateFormat 인스턴스 기본적으로 입니다.

이것이 문제가되지 않으면 샘플 코드를 게시하십시오.

그러나 어쨌든 훨씬 명확한 API를 제공하는 Joda-Time 을 사용하는 것이 좋습니다 .

tl; dr

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

해당 값을 나타내는 문자열을 생성하십시오.

Instant.now().toString()  

2016-09-13T23 : 30 : 52.123Z

세부

으로 존 소총으로 정답 언급하는 java.util.Date 객체는 없습니다 어떤 시간대를 ^† . 그러나 해당 toString구현은 해당 날짜-시간 값의 문자열 표현을 생성 할 때 JVM의 기본 시간대를 적용합니다. 순진한 프로그래머에게는 혼란스럽게도 Date 에는 시간대가있는 것 같지만 그렇지 않습니다.

java.util.Date, j.u.Calendar그리고 java.text.SimpleDateFormat자바와 함께 번들 클래스는 악명 골칫거리입니다. 피하십시오. 대신, 유능한 날짜 / 시간 라이브러리 중 하나를 사용하십시오.

• Java 8의 java.time. * 패키지
• 조다 타임

java.time (자바 8)

Java 8 은 뛰어난 java.time. * 패키지 를 제공하여 이전 java.util.Date/Calendar 클래스를 대체합니다.

UTC / GMT로 현재 시간을 얻는 것은 간단한 일 라이너입니다…

Instant instant = Instant.now();

이 Instant클래스는 java.time의 기본 빌딩 블록으로, 나노초 의 해상도로 UTC 의 타임 라인의 순간을 나타냅니다 .

Java 8에서는 현재 순간이 최대 밀리 초 해상도로 캡처됩니다. 자바 9 신선한 구현 제공 의 Clock호스트 컴퓨터의 시계 하드웨어의 능력에 따라,이 클래스의 전체 나노초 능력을 최대로 캡처에게 현재의 순간을.

이 toString메소드는 하나의 특정 ISO 8601 형식을 사용하여 해당 값의 문자열 표현을 생성 합니다 . 이 형식 은 초 를 나타내는 데 필요한 0, 3, 6 또는 9 자리 숫자 ( 밀리 초 , 마이크로 초 또는 나노초 )를 출력합니다.

보다 유연한 서식 또는 기타 추가 기능을 원하면 UTC 자체 ( ZoneOffset.UTCconstant )에 대해 UTC에서 오프셋을 0으로 적용하여을 얻습니다 OffsetDateTime.

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

콘솔로 덤프…

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

달릴 때…

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

java.time에 대하여

java.time의 프레임 워크는 나중에 자바 8에 내장되어 있습니다. 이 클래스는 까다로운 기존에 대신 기존 과 같은 날짜 - 시간의 수업을 java.util.Date, Calendar, SimpleDateFormat.

자세한 내용은 Oracle Tutorial을 참조하십시오 . 많은 예제와 설명을 보려면 스택 오버플로를 검색하십시오. 사양은 JSR 310 입니다.

Joda 타임 프로젝트는 지금에 유지 관리 모드 의로 마이그레이션을 조언 java.time의 클래스.

java.time 객체를 데이터베이스와 직접 교환 할 수 있습니다 . JDBC 4.2 이상을 준수 하는 JDBC 드라이버를 사용하십시오 . 문자열이 필요없고 수업이 필요 없습니다 .java.sql.*

java.time 클래스는 어디서 구할 수 있습니까?

• Java SE 8 , Java SE 9 , Java SE 10 , Java SE 11 이상 -번들로 구현 된 표준 Java API의 일부입니다.
  • Java 9에는 몇 가지 사소한 기능과 수정 사항이 추가되었습니다.
• Java SE 6 및 Java SE 7
  • 대부분의 java.time 기능은 ThreeTen-Backport의 Java 6 & 7로 백 포트됩니다 .
• 기계적 인조 인간
  • java.time 클래스 의 최신 버전의 Android 번들 구현 .
  • 이전 Android (<26)의 경우 ThreeTenABP 프로젝트 는 위에서 언급 한 ThreeTen-Backport를 채택합니다 . ThreeTenABP 사용 방법…을 참조하십시오 .

ThreeTen - 추가 프로젝트 추가 클래스와 java.time를 확장합니다. 이 프로젝트는 향후 java.time에 추가 될 수있는 입증 된 근거입니다. 당신은 여기에 몇 가지 유용한 클래스와 같은 찾을 수 있습니다 Interval, YearWeek, YearQuarter, 그리고 더 .

조다 타임

업데이트 : Joda-Time 현재 유지 관리 모드 인 프로젝트 는 java.time 클래스 로의 마이그레이션을 권장 합니다.

은 Using Joda 타임 자유의 선정 3 자 오픈 소스 라이브러리, 당신은 코드의 한 라인에 현재 날짜와 시간을 얻을 수 있습니다.

Joda-Time은 Java 8의 새로운 java.time. * 클래스에 영감을 주었지만 아키텍처는 다릅니다. 이전 버전의 Java에서는 Joda-Time을 사용할 수 있습니다. Joda-Time은 Java 8에서 계속 작동하며 지속적으로 관리되고 있습니다 (2014 년 기준). 그러나 Joda-Time 팀은 java.time으로의 마이그레이션을 권장합니다.

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

더 자세한 예제 코드 (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 );

콘솔로 덤프…

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

달릴 때…

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

표준 시간대 작업을 수행하는 코드 예를 더 보려면 는 비슷한 질문에 대한 내 대답 을 .

시간대

JVM의 현재 기본 시간대 (임시 변경 가능)에 내재적으로 의존하지 않고 항상 시간대를 지정하는 것이 좋습니다. 이러한 의존은 날짜 시간 작업의 혼란과 버그의 일반적인 원인 인 것 같습니다.

호출 할 때 now()할당 할 원하는 / 예상 시간대를 전달하십시오. DateTimeZone수업을 사용하십시오 .

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

이 클래스는 UTC 시간대에 대한 상수를 보유합니다 .

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

JVM의 현재 기본 시간대를 실제로 사용하려면 코드가 자체 문서화되도록 명시 적으로 호출하십시오.

DateTimeZone zoneDefault = DateTimeZone.getDefault();

ISO 8601

ISO 8601 형식 에 대해 읽어보십시오 . java.time 및 Joda-Time 모두 해당 표준의 합리적인 형식을 문자열 구문 분석 및 생성에 대한 기본값으로 사용합니다.

^† 실제로 java.util.Date 에는 표준 시간대 가 있으며 소스 코드 계층 아래에 ​​묻혀 있습니다. 대부분의 실제적인 목적으로 해당 시간대는 무시됩니다. 간단히 말해서, 우리는 java.util.Date에 시간대가 없다고 말합니다. 또한, 그 매장 시간대는 Date의 방법에 의해 사용되는 시간대가 아닙니다toString . 이 메소드는 JVM의 현재 기본 시간대를 사용합니다. 이 혼란스러운 클래스를 피하고 Joda-Time 및 java.time을 고수하는 더 많은 이유.

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()) );

이것은 확실히 UTC 시간을 String 및 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());

실제로 시간은 아니지만 표현이 바뀔 수 있습니다.

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

시간은 지구 어느 곳에서나 동일하지만 시간에 대한 인식은 위치에 따라 다를 수 있습니다.

캘린더 aGMTCalendar = Calendar.getInstance (TimeZone.getTimeZone ( "GMT")); 그런 다음 aGMTCalendar 객체를 사용하여 수행 된 모든 작업은 GMT 시간대로 수행되며 일광 절약 시간제 또는 고정 오프셋이 적용되지 않습니다.

잘못된!

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

과

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

같은 시간에 반환됩니다. 에 대한

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

이 코드는 현재 시간 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()));
    }
}

결과

2013-10-26 14:37:48 UTC

이것은 안드로이드에서 UTC 밀리 초를 얻는 데 효과적입니다.

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

Jon Skeet의 답변 에서 잘못된 것 같습니다 . 그는 말했다 :

java.util.Date항상 UTC입니다. 그것이 현지 시간이라고 생각하는 이유는 무엇입니까? 문제는 현지 시간대를 사용하는 캘린더 인스턴스를 사용하거나 현지 시간대를 사용하는 캘린더 인스턴스를 통해 표시하는 것 Date.toString()입니다.

그러나 코드 :

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

no Calendar와 no SimpleDateFormat를 사용하여 GMT (UTC 시간)가 아닌 현지 시간을 제공합니다 .

그래서 무언가가 잘못된 것 같습니다.

응답을 종합하면 코드는 다음과 같습니다.

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

은 현지 시간 대신 GMT 시간을 표시합니다. 이론적으로 날짜를 GMT에 저장하지만 현지 시간대로 시간을 되 돌리는 개체를 getTime.getHours()생성하기 때문에 누락되었습니다 Date().

필드가 UTC로 조정 된 Date 객체를 원한다면 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));

당신이 사용할 수있는:

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

그런 다음 aGMTCalendar 객체를 사용하여 수행 된 모든 작업은 GMT 시간대로 수행되며 일광 절약 시간제 또는 고정 오프셋이 적용되지 않습니다. 이전 포스터는 Date () 객체가 항상 GMT를 반환한다는 것이 정확하다고 생각합니다. 날짜 객체로 현지 표준 시간대로 변환 된 작업을 수행 할 때까지는 그렇지 않습니다.

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

직접 사용할 수 있습니다

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

와:

Calendar cal = Calendar.getInstance();

그런 다음 cal현재 날짜와 시간을 갖습니다.
다음을 사용하여 시간대의 현재 날짜 및 시간을 얻을 수도 있습니다.

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

cal.get(Calendar.DATE);다른 세부 정보에 대해 일정이나 다른 상수를 요청할 수 있습니다.
날짜 및 타임 스탬프는 Java에서 더 이상 사용되지 않습니다. 캘린더 클래스가 아닙니다.

다음은 GMT Timestamp 객체를 얻는 다른 제안입니다.

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));
}

다음은 문자열 형식으로 GMT 시간을 얻는 또 다른 방법입니다

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());

다음은 toUTC 구현입니다.

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

아마 그것을 향상시키는 몇 가지 방법이 있지만 그것은 나를 위해 작동합니다.

특정 시간대 및 특정 형식으로 시스템 시간을 렌더링하는 샘플 코드.

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);
    }

}

산출

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

이것을 간단하게 만들기 위해 Datein 을 만들려면 UTC다음을 사용할 수 있습니다 Calendar.

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

Calendar"UTC"사용을 위한 새로운 인스턴스를 생성 할 것입니다 TimeZone.

Date해당 캘린더 의 객체 가 필요한 경우을 사용할 수 있습니다 getTime().

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

이것은 나를 위해 일했으며 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();
    }

온라인 NTP 서버에서 올바른 UTC 시간을 얻으려면이 클래스를 사용하십시오.

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);             
}

}

다음과 함께 사용하십시오.

        long now = 0;

        NTP_UTC_Time client = new NTP_UTC_Time();

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

DateTimeString으로 UTC 시간 "지금"이 필요한 경우 함수를 사용하십시오.

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 "";
     }
    } 

다음과 같이 사용하십시오.

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);
}

간단히 말해서 달력 객체는 표준 시간대에 대한 정보를 저장하지만 cal.getTime ()을 수행하면 표준 시간대 정보가 손실됩니다. 시간대 변환의 경우 DateFormat 클래스를 사용하는 것이 좋습니다.

이것은 내 구현입니다.

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();    
}

날짜 구문 분석을 피하고 GMT에서 타임 스탬프를 원하면 다음을 사용할 수 있습니다.

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

joda 시간을 사용하고 로컬 오프셋없이 현재 시간을 밀리 초 단위로 원하면 다음을 사용할 수 있습니다.

long instant = DateTimeZone.UTC.getMillisKeepLocal(DateTimeZone.getDefault(), 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));
    }
}

산출:

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

필요에 따라 날짜 형식을 변경할 수 있습니다.

java.time 패키지를 사용하고 아래 코드를 포함하십시오.

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

또는

LocalDateTime now2 = LocalDateTime.now( ZoneOffset.UTC );

응용 프로그램 요구에 따라.