精华内容
下载资源
问答
  • javautc时间怎么转换为本地时间?

    千次阅读 2017-10-16 10:06:36
    java utc转本地时间的方法:1、创建一个格式化时间对象simpleDateFormat,并初始化格式yyyy-MM-dd HH:mm:ss:SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");2、创建时区对象utc...
    java utc转本地时间的方法:
    1、创建一个格式化时间对象simpleDateFormat,并初始化格式yyyy-MM-dd HH:mm:ss:
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    2、创建时区对象utcZone,获取utc所在的时区
    TimeZone utcZone = TimeZone.getTimeZone("UTC");
    3、设置utc时区,为转换做准备
    simpleDateFormat.setTimeZone(utcZone);
    4、获取本地时间,并转换
    Date myDate = simpleDateFormat.parse(rawQuestion.getString("AskDateTime"));
    5,按照上面的流程就转换本地时间了。
    展开全文
  • Java 获得时区,获得UTC时间

    万次阅读 2018-08-28 17:10:05
    Java 获得时区相关的类,主要是ZoneId,还有TimeZone(这个信息详细一点) ZoneId 主要是通过列表选定了一些规定位置,然后通过这些位置代表的时区,来划分时区,例如 中国就是Asia/Shanghai 然后根据时区,我们可以根据 ...

    Java 获得时区相关的类,主要是ZoneId,还有TimeZone(这个信息详细一点)

    ZoneId 主要是通过列表选定了一些规定位置,然后通过这些位置代表的时区,来划分时区,例如 中国就是Asia/Shanghai

    然后根据时区,我们可以根据 ZoneId ,来创建TimeZone 对象,再有 TimeZone 对象 来创建Calendar 对象

    测试代码如下:

    package test.time;
    
    import java.time.ZoneId;
    import java.util.Calendar;
    import java.util.TimeZone;
    
    /**
     * 测试java 时区相关
     * @author 12198
     *
     */
    
    @SuppressWarnings({ "static-access", "unused" })
    public class TestZoneId {
    	
    	public static void main(String[] args) {
    		System.out.println(TimeZone.getDefault());
    		for (String string : ZoneId.SHORT_IDS.keySet()) {
    			String id = ZoneId.SHORT_IDS.get(string);
    			ZoneId zoneId = ZoneId.of(id);
    			testSetZone(zoneId);
    //			printMessage(zoneId);
    		}
    //		testCalendar();
    	}
    
    	/**
    	 * 打印一些基本信息
    	 */
    	/*private static void printMessage(ZoneId zoneId) {
    //		ZoneId zoneId = ZoneId.systemDefault();
    		TimeZone timeZone = TimeZone.getTimeZone(zoneId);
    		
    		System.out.println(timeZone);
    		System.out.println(zoneId);
    		Set<String> availableZoneIds = zoneId.getAvailableZoneIds();
    		ZoneRules rules = zoneId.getRules();//standardOffsets [+08:05:43, +08:00]
    		ZoneOffset standardOffset = rules.getStandardOffset(Instant.now());//获得标准偏移量
    		System.out.println(standardOffset);//+08:00 totalSecond 28800 秒   28800000 毫秒
    		System.out.println(rules);
    	}*/
    	
    	
    	/**
    	 * 指定时区或设置默认时区
    	 */
    	public static void testSetZone(ZoneId zoneId){
    //		ZoneId zoneId = ZoneId.of(ZoneId.SHORT_IDS.get("ECT"));
    //		TimeZone timeZone = TimeZone.getDefault();
    		TimeZone timeZone2 = TimeZone.getTimeZone(zoneId);
    		System.out.println("zoneId:"+zoneId);
    //		System.out.println(timeZone);
    		System.out.println("timeZone2:"+timeZone2);
    		Calendar calendar = Calendar.getInstance(timeZone2);
    		System.out.println("zone_offset:" + calendar.get(Calendar.ZONE_OFFSET));
    		System.out.println("dst_offset:" + calendar.get(Calendar.DST_OFFSET));
    	}
    
    }
    

    把java 8中定义的 ZoneId.SHORT_IDS 集合拿出来遍历,可以发现时区偏移量 ZONE_OFFSET 在东半球为正数,在西半球为负数,dst_offset 夏时令偏移量 ,大部分时候为0,由于可以根据时区偏移量和夏时令偏移量来进行本地时间和UTC 时间的转换

    转换方法如下:

    package test.time;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    
    public class getUTCTime {
    	
    	/**
         * 获得世界协调时的近似值
         * @return  Date
         */
       public static Date getUTCTime(){
       	Calendar cal = Calendar.getInstance();
       	//获得时区和 GMT-0 的时间差,偏移量
       	int offset = cal.get(Calendar.ZONE_OFFSET);
       	//获得夏令时  时差
       	int dstoff = cal.get(Calendar.DST_OFFSET);
       	cal.add(Calendar.MILLISECOND, - (offset + dstoff));
    		return cal.getTime();
       	
       }
       
       /**
        *  获得世界协调时的近似值
        * @param format	格式化的时间格式
        * @return   String
        */
       public static String getUTCTime(String format){
       	String formatDate = format(getUTCTime(), format);
    		return formatDate;
       }
       
       
       /**
        * 根据传入得本地时间获得 获得 这个对应得UTC 时间
        * @param localDate
        * @param format
        * @return
        */
       public static String getUTCTimeByLocalTime(String localDate,String format){
       	Calendar cal = Calendar.getInstance();
       	//获得时区和 GMT-0 的时间差,偏移量
       	int offset = cal.get(Calendar.ZONE_OFFSET);
       	//获得夏令时  时差
       	int dstoff = cal.get(Calendar.DST_OFFSET);
       	Date date = new Date(getMillSecond(format, localDate) - (offset + dstoff));//获得当前是UTC时区的时间毫秒值
       	String formatDate = format(date, format);
    		return formatDate;
       	
       }
       
       
       /**
        * 根据utc时间的字符串形式,获得当前时区的本地时间
        * @param utcTime  时间字符串形式
        * @param format   时间格式为:yyyyMMddHHmmssS   精确到毫秒值
        * @return
        */
       public static Date getLocalZoneTime(String utcTime,String format){
       	Calendar cal = Calendar.getInstance();
       	//获得时区和 GMT-0 的时间差,偏移量
       	int offset = cal.get(Calendar.ZONE_OFFSET);
       	//获得夏令时  时差
       	int dstoff = cal.get(Calendar.DST_OFFSET);
       	//cal.add(getMillSecond(format, utcTime),+(offset + dstoff));
       	Date date = new Date(getMillSecond(format, utcTime) + (offset + dstoff));//获得当前是时区的时间毫秒值
    		return date;
       	
       }
       
       /**
        * 根据utc时间的字符串形式,获得当前时区的本地时间
        * @param utcTime  时间字符串形式
        * @param format   时间格式为:yyyyMMddHHmmssS   精确到毫秒值
        * @return
        */
       public static String getLocalZoneTimeString(String utcTime,String format){
       	return format(getLocalZoneTime(utcTime, format),format);
       }
       
       
       /**
        * 根据时间的字符串形式获得时间的毫秒值
        * @param format   最好为yyyyMMddHHmmssS 精确到毫秒值,这样转换没有精度损失
        * @return
        */
       public static long getMillSecond(String format,String time){
       	Date parse = parse(time, format);
       	return parse.getTime();
       }
       
       
       /**
        * 使用用户格式格式化日期
        * @param date 日期
        * @param pattern 日期格式
        * @return
        */
       public static String format(Date date, String pattern) {
           String returnValue = "";
           if (date != null) {
               SimpleDateFormat df = new SimpleDateFormat(pattern);
               returnValue = df.format(date);
           }
           return (returnValue);
       }
       
       /**
        * 使用用户格式提取字符串日期
        * @param strDate 日期字符串
        * @param pattern 日期格式
        * @return
        */
       public static Date parse(String strDate, String pattern) {
           SimpleDateFormat df = new SimpleDateFormat(pattern);
           try {
               return df.parse(strDate);
           } catch (ParseException e) {
               e.printStackTrace();
               return null;
           }
       }
    
    }
    

     

    展开全文
  • 当我创建一个新的Date对象时,它被初始化为当前时间,但是在本地时区。 如何获取格林尼治标准时间的当前日期和时间

    当我创建一个新的Date对象时,它被初始化为当前时间,但是在本地时区。 如何获取格林尼治标准时间的当前日期和时间?


    #1楼

    您可以直接使用

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

    #2楼

    如果您希望Date对象的字段经过UTC调整,则可以使用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));
    

    #3楼

    以下是获取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));
    }
    

    #4楼

    只是为了简化操作,要在UTC创建Date ,您可以使用Calendar

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

    它将使用“ UTC” TimeZoneCalendar构造一个新实例。

    如果您需要该日历中的Date对象,则可以使用getTime()


    #5楼

    乔恩·斯凯特(Jon Skeet)的回答似乎不正确。 他说:

    java.util.Date始终使用UTC。 是什么让您认为这是当地时间? 我怀疑问题在于您是通过使用本地时区的Calendar实例显示它,还是可能使用也使用本地时区的Date.toString()来显示它。

    但是,代码:

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

    完全不使用CalendarSimpleDateFormat给出本地时间,而不是GMT(UTC小时)。

    这就是为什么似乎不正确的原因。

    将响应汇总在一起,代码为:

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

    显示的是GMT小时而不是本地时间-请注意,缺少getTime.getHours() ,因为这会创建一个Date()对象,该对象理论上将日期存储在GMT中,但会返回本地时区中的小时数。


    #6楼

    这是获取String格式的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());
    

    #7楼

    简单地说。 日历对象存储有关时区的信息,但是当您执行cal.getTime()时,时区信息将丢失。 因此,对于时区转换,我建议使用DateFormat类...


    #8楼

    这对我有用,返回格林尼治标准时间的时间戳!

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

    #9楼

    这适用于在Android中获取UTC毫秒。

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

    #10楼

    此代码显示当前时间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
    

    #11楼

    tl; dr

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

    生成一个字符串来表示该值:

    Instant.now().toString()  
    

    2016-09-13T23:30:52.123Z

    细节

    正如乔恩·斯基特(Jon Skeet)的正确回答所指出的那样,java.util.Date对象没有时区 。 但是,它的toString实现在生成该日期时间值的String表示形式时将应用JVM的默认时区。 令天真的程序员感到困惑的是,“日期” 似乎有一个时区,但没有。

    与Java捆绑在一起的java.util.DatejuCalendarjava.text.SimpleDateFormat类非常麻烦。 避免他们。 而是使用以下任何一种合格的日期时间库:

    java.time(Java 8)

    Java 8带来了一个出色的新java.time。*包,以取代旧的java.util.Date/Calendar类。

    在UTC / GMT中获取当前时间是一个简单的方法。

    Instant instant = Instant.now();
    

    Instant类是java.time基本构建块,代表时间线上的时刻UTC ,分辨率为纳秒

    在Java 8中,当前时刻只能以毫秒级的分辨率捕获。 Java 9带来了全新Clock 实现 ,具体取决于您主机时钟硬件的能力,以此类的完整纳秒能力捕获当前时刻。

    它的toString方法使用一种特定的ISO 8601格式生成其值的String表示形式 。 该格式根据需要输出零,三,六或九位数字( 毫秒微秒纳秒 )来表示的分数。

    如果您想要更灵活的格式设置或其他附加功能,则对UTC本身(UTC 常量ZoneOffset.UTC常数 )应用UTC偏移量为零以获得OffsetDateTime

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

    转储到控制台...

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

    运行时...

    now: 2014-01-21T23:42:03.522Z
    

    Java中的日期时间类型表,包括现代的和传统的。


    关于java.time

    java.time框架内置于Java 8及更高版本中。 这些类取代了麻烦的旧的旧式日期时间类,例如java.util.DateCalendarSimpleDateFormat

    要了解更多信息,请参见Oracle教程 。 并在Stack Overflow中搜索许多示例和说明。 规格为JSR 310

    现在处于维护模式Joda-Time项目建议迁移到java.time类。

    您可以直接与数据库交换java.time对象。 使用与JDBC 4.2或更高版本兼容的JDBC驱动程序 。 不需要字符串,不需要java.sql.*类。

    在哪里获取java.time类?

    与哪个版本的Java或Android一起使用的哪个java.time库的表

    ThreeTen-Extra项目使用其他类扩展了java.time。 该项目为将来可能在java.time中添加内容提供了一个试验场。 您可以在这里找到一些有用的类,比如IntervalYearWeekYearQuarter ,和更多


    乔达时代

    更新:现在处于维护模式Joda-Time项目建议迁移到java.time类。

    使用Joda-Time 3rd-party开源免费库,您只需一行代码即可获取当前日期时间。

    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。


    #12楼

    使用此类可以从在线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();
            }
    

    如果您需要UTC时间“ now”作为DateTimeString,请使用以下函数:

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

    #13楼

    以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
    

    #14楼

    您可以使用:

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

    然后,使用aGMTCalendar对象执行的所有操作都将在GMT时区完成,并且不会应用夏令时或固定的偏移量。 我认为上一个发布者是正确的,Date()对象始终返回GMT,直到您对将其转换为本地时区的date对象执行操作之前,它不会。


    #15楼

    这是我的实现:

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

    #16楼

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

    #17楼

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

    #18楼

    日历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.
    

    #19楼

    尽管java.util.Date的值通常与UTC有关,但没有特定的时区。 是什么让您认为这是当地时间?

    准确地说: java.util.Date的值是自Unix纪元以来的毫秒数,该纪元发生在UTC的1970年1月1日午夜。 相同的纪元也可以在其他时区进行描述,但是传统的描述是以UTC表示的。 由于距固定纪元以来已有毫秒数,因此java.util.Date的值在世界各地在任何特定时刻都是相同的,而与本地时区无关。

    我怀疑问题在于您是通过使用本地时区的Calendar实例显示它,还是使用也使用本地时区的Date.toString()SimpleDateFormat实例(默认情况下也使用本地)来显示它时区。

    如果这不是问题,请发布一些示例代码。

    但是,无论如何,我还是建议您使用Joda-Time ,它提供了更加清晰的API。


    #20楼

    带有:

    Calendar cal = Calendar.getInstance();
    

    然后cal具有当前日期和时间。
    您还可以通过以下方式获取时区的当前日期和时间:

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

    您可以询问cal.get(Calendar.DATE); 或其他有关其他详细信息的日历常量。
    日期和时间戳在Java中已弃用。 日历类不是。


    #21楼

    如果您使用的是joda时间,并且想要以毫秒为单位的当前时间而不需要本地偏移 ,则可以使用以下命令:

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

    #22楼

    如果要避免解析日期,而只需要GMT中的时间戳,则可以使用:

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

    #23楼

    这是我对toUTC的实现:

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

    可能有几种方法可以改善它,但对我有用。


    #24楼

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

    #25楼

    实际上不是时间,但是它的表示形式可以更改。

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

    在地球的任何一点上,时间都是相同的,但是根据位置的不同,我们对时间的理解可能会有所不同。


    #26楼

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

    #27楼

    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
    

    您可以根据需要更改日期格式。


    #28楼

    使用java.time包,并包含以下代码-

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

    要么

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

    取决于您的应用程序需求。


    #29楼

    这肯定会返回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;
    }
    

    #30楼

    用于以特定时区和特定格式呈现系统时间的示例代码。

    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
    
    展开全文
  • 经过本人多次的测试,终于得到以下记录...//得到的是CST(美国时区)的时间,但在java中显示的是你系统当前的时间,也就是你所在时区的时间 Date date = new Date(); //得到的是距离1970.1.1 00:00:00以来的CST时区...

    经过本人多次的测试,终于得到以下记录:

    环境:
    mysql5.7
    mysql驱动8.0以上
    JDK8

    1.mysql设置serverTimeZone=UTC时

    • 在java中创建
    //得到的是CST(美国时区)的时间,但在java中显示的是你系统当前的时间,也就是你所在时区的时间
    Date date  = new Date();
    //得到的是距离1970.1.1 00:00:00以来的CST时区的毫秒数
    long time = date.getTime();
    //将Date转换为String,从这一步可以发现time得到是距离1970.1.1 00:00:00以来的CST时区的毫秒数
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss", Locale.CHINA);
    String strDate = simpleDateFormat.format(time);
    
    • 不管数据库字段设置成什么类型的时间(Date,DateTime,TimeStamp),都会将后端传来的时间数据转换为UTC时间
    • 查询数据库,不管后端字段设置成(Date,TimeStamp),最终显示的是数据库中原本的数据,发现并不会转换为当前时区的时间。

    未完待续。。。

    展开全文
  • 上篇文章铺设所有涉及到的概念解释,例如GMT、UTC、夏令时、时间戳等等,若你还没看过,不仅强烈建议而是强制建议你前往用花5分钟看一下,因为日期时间处理较为特殊,实战必须基于对概念的了解,否则很可能依旧...
  • java时间类的使用

    2014-08-10 22:44:00
    日期的使用: 1、创建日期 2、日期格式化显示 3、日期的转换 4、两个日期的大小比较、日期的加减 一些知识: 全球24个时区的瓜分 格林威治标准时间GMT 世界协调时间(世界标准时间UTC 夏日节约时间DST CST时间 CST...
  • Java使用Joda-Time处理日期和时间

    千次阅读 2019-04-25 14:59:04
    4.1 获取当前系统时间 4.2 通过给定的毫秒值创建 4.3 通过给定的对象创建 4.4 通过指定字段值创建 5. Joda-Time日期操作 6. Joda-Time日期格式化 7. 一些源码 7.1 计算指定年的毫秒数的方法 7.2 将UTC毫秒数切换成本...
  • 这个主要是UTC时间问题 UTC:世界标准时间,中国标准时间是东八区的,比它晚整整8个小时。 mysql数据库创建后。默认的时区比东八区少了八个小时。如果sql语句中使用到mysql的时间的话就会比正常时间少了八个小时。...
  • Java日期

    2020-05-31 21:22:16
    UTC时间是:从 1970 年 1 月 1 日 00:00:00 GMT)以来的指定毫秒数。 Date d = new Date(); 2.Date 对象使用SimpleDateFormat格式化日期, yyyy 是完整的公元年,MM 是月份,dd 是日期,HH:mm:ss 是时、分、秒。注意:...
  • wgu-c195-software-2 WGU C195的Java项目-软件II高级Java概念 这是我为C195设计的完整项目-首次尝试通过。 Java技能 ...管理时间戳并将其转换为各个时区-了解UTC时间 使用SQL语句简化应用程序 使用更高级M
  • Java Clock.millis获得当前时钟的毫秒数。...根据Java,我们应该只在高性能的用例中使用millis,在这种情况下,创建一个对象是不可接受的。 在Java文档中找到Clock.millis的声明。 public long millis()
  • JAVA - 日期处理类

    2018-06-11 23:28:12
    Date类Date类通过一个从UTC时间1970年1月1日 00:00:00到其代表的时间之间的毫秒数来表示时间。* 类加载import java.util.Date;* 构造Date类以系统当前的毫秒数创建当前时间对象public Date();根据给定的毫秒值创建...
  • LocalDateTime类的ofInstant(Instant Instant,ZoneId zone)方法用于使用Instant和区域ID创建LocalDateTime的实例。 LocalDateTime的计算遵循以下步骤。 区域Id和Instant用于从UTC /格林威治获取偏移量,因为每个...
  • 文章目录1. 简介2. LocalDate2.1 创建2.2 计算2.3 比较2.4 其他3. LocalDateTime4. DateTimeFormatter5....Java中的时间相关库真是一言难尽,以至于被逼出了一个joda库,Java时间处理库一直被吐槽当
  • new Timestamp(System.currentTimeMillis())创建Timestamp插入到数据库中时会出现时间不对问题,这是因为数据库时区问题 如果你设置serverTimezone=UTC,连接不报错, 但是我们在用java代码插入到数据库时间的时候...
  • 一、时间类 1)Java.lang.System类 System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以...Date():使用无参构造器创建对象可以获取本地当地时间 >Date(long date)
  • ocfl-java-http-源码

    2021-02-11 02:40:35
    OCFL-JAVA-HTTP ... API GET / 返回{“ OCFL ROOT”:...}作为JSON GET / <对象ID> /文件 添加includeDeleted = true URL参数以请求所有文件,... 添加objectTimestamps = true URL参数以请求创建/ lastModified时间
  • java中级笔试题及答案2015 如何加入? 加入 。 创建拉取请求。 将您在此文件中的简短联系信息添加到下面的 和 部分。 请注意两个地方的字母顺序。 发送 PR 后,您将获得贡献者权利,使您可以随时更改或删除您的条目...
  • 由于在docker hub上pull下来的官方tomcat镜像中,tomcat采用的时间格式为UTC格式,并且的webapps目录存放了默认项目,而且,tomcat也没有设置相关的JAVA_OPTS参数。 因此,自定义自己的Dockerfile来创建符合的...
  • Java当中对Date的处理: 首先提出问题: 1. 什么叫UTC,UT? GMT? 世界时间时间标准时间,格林威治时间。 2. 怎么得到当前系统时间? 第一种方式:System.currentTimeMills(); 返回的是,当先系统时间与...
  • java项目多时区问题解决方式

    千次阅读 2019-02-20 20:34:12
    部署项目的服务器时区为UTC(协调世界时),客户端是CST(可理解为中国的标准时间),两者其实相差8小时,所以导致界面上的创建时间永远都少了8小时。   思考:为什么会出现这种多时区问题呢? 看了下代码,发现...
  • java中Calendar.getInstance()和new Date()的差别如下: ...new Date()是创建了一个date对象,默认是utc格式的。 二者可以相互转化: Calendar calendar = Calendar.getInstance(); // 从一个 Calend...
  • 名词解释 ISO 日期格式: ISO 日期格式(ISODatetime)是 ISO 8601 标准规定的时间表示方式。云点播如无特别指定,所有时间相关...下载腾讯云媒资管理下的视频,回调模式解析返回信息的创建时间: CreateTime String 媒
  • java中Calendar.getInstance()和new Date()的差别如下:Calendar.getInstance()是获取一个Calendar对象并可以进行时间的计算,时区的指定new Date()是创建了一个date对象,默认是utc格式的。二者可以相互转化:...
  • 偶然间发现数据库的创建时间和系统的时间不一样,找原因,说需要在配置文件里配置成东八区的时间,我找了我的yml文件,发现本来就已经有这个配置了 spring: jackson: time-zone: GMT+8 date-format: yyyy-MM-dd ...
  • ps.setDate(1,new java.sql.Date(GpsDate.getTime())); ps.setLong(2, GpsDate.getTime()); ps.setString(3, strs[2]); ps.setString(4, strs[3]); ps.setString(5,strs[4]); ...
  • Javascript引用类型之时间Date  JavaScript中的Date类型是在早期Java中的java.util.Date类基础上构建的。...当没有向构造函数传递日期参数时,将创建一个拥有当前日期和时间的对象。 当然,如果想根据特定的日期和
  • 29-Mar-2021 18:17:56.708 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log 服务器构建: Sep 10 2020 08:20:30 UTC 29-Mar-2021 18:17:56.708 信息 [main] org.apache.catalina.startup....
  • Java运行打印日志与系统时间不一致问题解决方法: 1.修改/etc/sysconfig/clock文件,若没有该文件则创建。 #编辑/etc/sysconfig/clock vim /etc/sysconfig/clock #添加如下内容 ZONE="Asia/Shanghai" UTC=false ...
  • JVM与linux系统时间不一致问题

    千次阅读 2018-09-04 17:47:36
    Java运行打印日志与系统时间不一致问题解决方法: 1.修改/etc/sysconfig/clock文件,若没有该文件则创建。 #编辑/etc/sysconfig/clock sudo vim /etc/sysconfig/clock #添加如下内容 ZONE="Asia/Shanghai" UTC=...

空空如也

空空如也

1 2 3 4
收藏数 72
精华内容 28
关键字:

java创建utc时间

java 订阅