将符合ISO 8601的字符串转换为java.util.Date

最新推荐文章于 2024-06-13 09:54:35 发布

p15097962069

最新推荐文章于 2024-06-13 09:54:35 发布

阅读量2.1k

点赞数 1

文章标签： java date iso8601

原文链接：https://tr.sofbug.com/question/9Eov

版权

我正在尝试将ISO 8601格式的String转换为java.util.Date 。

如果与区域设置（比较示例）一起使用，我发现模式yyyy-MM-dd'T'HH:mm:ssZ符合ISO8601。

但是，使用java.text.SimpleDateFormat不能转换格式正确的String 2010-01-01T12:00:00+01:00 。我必须先将其转换为2010-01-01T12:00:00+0100 ，而不能使用冒号。

所以，目前的解决方案是

SimpleDateFormat ISO8601DATEFORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.GERMANY);
String date = "2010-01-01T12:00:00+01:00".replaceAll("\\+0([0-9]){1}\\:00", "+0$100");
System.out.println(ISO8601DATEFORMAT.parse(date));

显然不是那么好。我是否缺少某些东西或有更好的解决方案？

回答

感谢JuanZe的评论，我找到了Joda-Time魔术，这里也对此进行了描述。

因此，解决方案是

DateTimeFormatter parser2 = ISODateTimeFormat.dateTimeNoMillis();
String jtdate = "2010-01-01T12:00:00+01:00";
System.out.println(parser2.parseDateTime(jtdate));

或更简单地说，通过构造函数使用默认解析器：

DateTime dt = new DateTime( "2010-01-01T12:00:00+01:00" ) ;

对我来说，这很好。

#1楼

好的，这个问题已经回答了，但是我还是放弃了。它可能会帮助某人。

我一直在寻找Android （API 7）的解决方案 。

乔达（Joda）毫无疑问-它庞大且初始化缓慢。对于该特定目的，这似乎也是一个重大的过大杀伤力。
涉及javax.xml答案不适用于Android API 7。

最终实现了这个简单的类。它仅涵盖最常见的ISO 8601字符串形式，但是在某些情况下（当您完全确定输入将采用这种格式时）就足够了。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * Helper class for handling a most common subset of ISO 8601 strings
 * (in the following format: "2008-03-01T13:00:00+01:00"). It supports
 * parsing the "Z" timezone, but many other less-used features are
 * missing.
 */
public final class ISO8601 {
    /** Transform Calendar to ISO 8601 string. */
    public static String fromCalendar(final Calendar calendar) {
        Date date = calendar.getTime();
        String formatted = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
            .format(date);
        return formatted.substring(0, 22) + ":" + formatted.substring(22);
    }

    /** Get current date and time formatted as ISO 8601 string. */
    public static String now() {
        return fromCalendar(GregorianCalendar.getInstance());
    }

    /** Transform ISO 8601 string to Calendar. */
    public static Calendar toCalendar(final String iso8601string)
            throws ParseException {
        Calendar calendar = GregorianCalendar.getInstance();
        String s = iso8601string.replace("Z", "+00:00");
        try {
            s = s.substring(0, 22) + s.substring(23);  // to get rid of the ":"
        } catch (IndexOutOfBoundsException e) {
            throw new ParseException("Invalid length", 0);
        }
        Date date = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").parse(s);
        calendar.setTime(date);
        return calendar;
    }
}

性能说明：每次实例化新的SimpleDateFormat都是为了避免Android 2.1中的错误。如果您像我一样惊讶，请参阅这个谜语。对于其他Java引擎，您可以将实例缓存在私有静态字段中（使用ThreadLocal，以确保线程安全）。

#2楼

我认为我们应该使用

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

为日期2010-01-01T12:00:00Z

#3楼

Apache Jackrabbit使用ISO 8601格式来保留日期，并且有一个帮助器类来解析它们：

org.apache.jackrabbit.util.ISO8601

带有jackrabbit-jcr-commons 。

#4楼

基本功能礼貌：@wrygiel。

此函数可以将ISO8601格式转换为可以处理偏移值的Java Date。根据ISO 8601的定义，偏移可以以不同的格式提及。

±[hh]:[mm]
±[hh][mm]
±[hh]

Eg:  "18:30Z", "22:30+04", "1130-0700", and "15:00-03:30" all mean the same time. - 06:30PM UTC

此类具有要转换的静态方法

ISO8601字符串转换为Date（Local TimeZone）对象
ISO8601字符串的日期
夏令时自动计算

示例ISO8601字符串

/*       "2013-06-25T14:00:00Z";
         "2013-06-25T140000Z";
         "2013-06-25T14:00:00+04";
         "2013-06-25T14:00:00+0400";
         "2013-06-25T140000+0400";
         "2013-06-25T14:00:00-04";
         "2013-06-25T14:00:00-0400";
         "2013-06-25T140000-0400";*/


public class ISO8601DateFormatter {

private static final DateFormat DATE_FORMAT_1 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
private static final DateFormat DATE_FORMAT_2 = new SimpleDateFormat("yyyy-MM-dd'T'HHmmssZ");
private static final String UTC_PLUS = "+";
private static final String UTC_MINUS = "-";

public static Date toDate(String iso8601string) throws ParseException {
    iso8601string = iso8601string.trim();
    if(iso8601string.toUpperCase().indexOf("Z")>0){
        iso8601string = iso8601string.toUpperCase().replace("Z", "+0000");
    }else if(((iso8601string.indexOf(UTC_PLUS))>0)){
        iso8601string = replaceColon(iso8601string, iso8601string.indexOf(UTC_PLUS));
        iso8601string = appendZeros(iso8601string, iso8601string.indexOf(UTC_PLUS), UTC_PLUS);
    }else if(((iso8601string.indexOf(UTC_MINUS))>0)){
        iso8601string = replaceColon(iso8601string, iso8601string.indexOf(UTC_MINUS));
        iso8601string = appendZeros(iso8601string, iso8601string.indexOf(UTC_MINUS), UTC_MINUS);
    }

    Date date = null;
    if(iso8601string.contains(":"))
        date = DATE_FORMAT_1.parse(iso8601string);
    else{
        date = DATE_FORMAT_2.parse(iso8601string);
    }
    return date;
}

public static String toISO8601String(Date date){
    return DATE_FORMAT_1.format(date);
}

private static String replaceColon(String sourceStr, int offsetIndex){
    if(sourceStr.substring(offsetIndex).contains(":"))
        return sourceStr.substring(0, offsetIndex) + sourceStr.substring(offsetIndex).replace(":", "");
    return sourceStr;
}

private static String appendZeros(String sourceStr, int offsetIndex, String offsetChar){
    if((sourceStr.length()-1)-sourceStr.indexOf(offsetChar,offsetIndex)<=2)
        return sourceStr + "00";
    return sourceStr;
}

}

#5楼

Jackson-databind库还具有做到这一点的ISO8601DateFormat类（在ISO8601Utils中的实际实现。

ISO8601DateFormat df = new ISO8601DateFormat();
Date d = df.parse("2010-07-28T22:25:51Z");

#6楼

Java 7文档所祝福的方式：

DateFormat df1 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
String string1 = "2001-07-04T12:08:56.235-0700";
Date result1 = df1.parse(string1);

DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");
String string2 = "2001-07-04T12:08:56.235-07:00";
Date result2 = df2.parse(string2);

你可以找到在部分例子更多例子的SimpleDateFormat的Javadoc 。

#7楼

解析ISO8601时间戳的另一种非常简单的方法是使用org.apache.commons.lang.time.DateUtils ：

import static org.junit.Assert.assertEquals;

import java.text.ParseException;
import java.util.Date;
import org.apache.commons.lang.time.DateUtils;
import org.junit.Test;

public class ISO8601TimestampFormatTest {
  @Test
  public void parse() throws ParseException {
    Date date = DateUtils.parseDate("2010-01-01T12:00:00+01:00", new String[]{ "yyyy-MM-dd'T'HH:mm:ssZZ" });
    assertEquals("Fri Jan 01 12:00:00 CET 2010", date.toString());
  }
}

#8楼

JAVA 1.7的SimpleDateFormat对ISO 8601格式具有很酷的模式。

类SimpleDateFormat

这是我所做的：

Date d = new SimpleDateFormat( "yyyy-MM-dd'T'HH:mm:ss.SSSZ",
         Locale.ENGLISH).format(System.currentTimeMillis());

#9楼

这似乎最适合我：

public static Date fromISO8601_( String string ) {

    try {
            return new SimpleDateFormat ( "yyyy-MM-dd'T'HH:mm:ssXXX").parse ( string );
    } catch ( ParseException e ) {
        return Exceptions.handle (Date.class, "Not a valid ISO8601", e);
    }


}

我需要将JavaScript日期字符串来回转换为Java。我发现以上工作与建议。有一些使用SimpleDateFormat的示例很接近，但似乎不是建议的子集：

http://www.w3.org/TR/NOTE-datetime

并受PLIST和JavaScript字符串支持，而这正是我所需要的。

这似乎是那里最常见的ISO8601字符串形式，也是很好的子集。

他们给出的示例是：

1994-11-05T08:15:30-05:00 corresponds 
November 5, 1994, 8:15:30 am, US Eastern Standard Time.

 1994-11-05T13:15:30Z corresponds to the same instant.

我也有一个快速版本：

final static int SHORT_ISO_8601_TIME_LENGTH =  "1994-11-05T08:15:30Z".length ();
                                            // 01234567890123456789012
final static int LONG_ISO_8601_TIME_LENGTH = "1994-11-05T08:15:30-05:00".length ();


public static Date fromISO8601( String string ) {
    if (isISO8601 ( string )) {
        char [] charArray = Reflection.toCharArray ( string );//uses unsafe or string.toCharArray if unsafe is not available
        int year = CharScanner.parseIntFromTo ( charArray, 0, 4 );
        int month = CharScanner.parseIntFromTo ( charArray, 5, 7 );
        int day = CharScanner.parseIntFromTo ( charArray, 8, 10 );
        int hour = CharScanner.parseIntFromTo ( charArray, 11, 13 );

        int minute = CharScanner.parseIntFromTo ( charArray, 14, 16 );

        int second = CharScanner.parseIntFromTo ( charArray, 17, 19 );

        TimeZone tz ;

         if (charArray[19] == 'Z') {

             tz = TimeZone.getTimeZone ( "GMT" );
         } else {

             StringBuilder builder = new StringBuilder ( 9 );
             builder.append ( "GMT" );
             builder.append( charArray, 19, LONG_ISO_8601_TIME_LENGTH - 19);
             String tzStr = builder.toString ();
             tz = TimeZone.getTimeZone ( tzStr ) ;

         }
         return toDate ( tz, year, month, day, hour, minute, second );

    }   else {
        return null;
    }

}

...

public static int parseIntFromTo ( char[] digitChars, int offset, int to ) {
    int num = digitChars[ offset ] - '0';
    if ( ++offset < to ) {
        num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
        if ( ++offset < to ) {
            num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
            if ( ++offset < to ) {
                num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                if ( ++offset < to ) {
                    num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                    if ( ++offset < to ) {
                        num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                        if ( ++offset < to ) {
                            num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                            if ( ++offset < to ) {
                                num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                                if ( ++offset < to ) {
                                    num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return num;
}


public static boolean isISO8601( String string ) {
      boolean valid = true;

      if (string.length () == SHORT_ISO_8601_TIME_LENGTH) {
          valid &=  (string.charAt ( 19 )  == 'Z');

      } else if (string.length () == LONG_ISO_8601_TIME_LENGTH) {
          valid &=  (string.charAt ( 19 )  == '-' || string.charAt ( 19 )  == '+');
          valid &=  (string.charAt ( 22 )  == ':');

      } else {
          return false;
      }

    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
    // "1 9 9 4 - 1 1 - 0 5 T 0 8 : 1 5 : 3 0 - 0 5 : 0 0

    valid &=  (string.charAt ( 4 )  == '-') &&
                (string.charAt ( 7 )  == '-') &&
                (string.charAt ( 10 ) == 'T') &&
                (string.charAt ( 13 ) == ':') &&
                (string.charAt ( 16 ) == ':');

    return valid;
}

我尚未对其进行基准测试，但是我想它将很快。似乎有效。 :)

@Test
public void testIsoShortDate() {
    String test =  "1994-11-05T08:15:30Z";

    Date date = Dates.fromISO8601 ( test );
    Date date2 = Dates.fromISO8601_ ( test );

    assertEquals(date2.toString (), date.toString ());

    puts (date);
}

@Test
public void testIsoLongDate() {
    String test =  "1994-11-05T08:11:22-05:00";

    Date date = Dates.fromISO8601 ( test );
    Date date2 = Dates.fromISO8601_ ( test );

    assertEquals(date2.toString (), date.toString ());

    puts (date);
}

#10楼

tl; dr

OffsetDateTime.parse ( "2010-01-01T12:00:00+01:00" )

使用java.time

Java 8及更高版本中的新java.time包受到Joda-Time的启发。

OffsetDateTime类表示时间轴上具有距UTC偏移量而不是时区的时刻。

OffsetDateTime odt = OffsetDateTime.parse ( "2010-01-01T12:00:00+01:00" );

调用toString生成标准ISO 8601格式的字符串：

2010-01-01T12：00 + 01：00

要通过UTC镜头看到相同的值，请提取一个Instant或将偏移量从+01:00调整为00:00 。

Instant instant = odt.toInstant();

…要么…

OffsetDateTime odtUtc = odt.withOffsetSameInstant( ZoneOffset.UTC );

如果需要，请调整为时区。时区是区域的UTC偏移值的历史记录，带有一组处理异常的规则，例如夏令时（DST）。因此，请尽可能使用时区，而不仅仅是偏移量。

ZonedDateTime zonedDateTimeMontréal = odt.atZoneSameInstant( ZoneId.of( "America/Montreal" ) );

关于java.time

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

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

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

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

在哪里获取java.time类？

Java SE 8 ， Java SE 9 ， Java SE 10和更高版本
- 内置的
- 标准Java API的一部分，具有捆绑的实现。
- Java 9添加了一些次要功能和修复。
Java SE 6和Java SE 7
- java.time的许多功能在ThreeTen- Backport中都被反向移植到Java 6和7。
安卓系统
- 更高版本的Android捆绑了java.time类的实现。
- 对于早期的Android（<26）， ThreeTenABP项目改编了ThreeTen-Backport （如上所述）。请参阅如何使用ThreeTenABP… 。

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

#11楼

我认为很多人想做的就是解析JSON日期字符串。如果您访问此页面，您很可能希望将JavaScript JSON日期转换为Java日期。

要显示JSON日期字符串是什么样的：

    var d=new Date();
    var s = JSON.stringify(d);

    document.write(s);
    document.write("<br />"+d);


    "2013-12-14T01:55:33.412Z"
    Fri Dec 13 2013 17:55:33 GMT-0800 (PST)

JSON日期字符串为2013-12-14T01：55：33.412Z。

JSON规范并未说出日期，但是上面是一种非常特定的ISO 8601格式，而ISO_8601则大得多，尽管是非常重要的一个，但它仅仅是一个子集。

请参阅http://www.json.org请参阅http://en.wikipedia.org/wiki/ISO_8601请参阅http://www.w3.org/TR/NOTE-datetime

碰巧的是，我写了一个JSON解析器和PLIST解析器，它们都使用ISO-8601，但不使用相同的位。

/*
    var d=new Date();
    var s = JSON.stringify(d);

    document.write(s);
    document.write("<br />"+d);


    "2013-12-14T01:55:33.412Z"
    Fri Dec 13 2013 17:55:33 GMT-0800 (PST)


 */
@Test
public void jsonJavaScriptDate() {
    String test =  "2013-12-14T01:55:33.412Z";

    Date date = Dates.fromJsonDate ( test );
    Date date2 = Dates.fromJsonDate_ ( test );

    assertEquals(date2.toString (), "" + date);

    puts (date);
}

我为我的项目写了两种方法来做到这一点。一种标准，一种快速。

同样，JSON日期字符串是ISO 8601的非常具体的实现。

（我在另一个答案中张贴了另一个答案，该答案应该适用于PLIST日期，这是一种不同的ISO 8601格式）。

JSON日期如下：

public static Date fromJsonDate_( String string ) {

    try {

        return new SimpleDateFormat ( "yyyy-MM-dd'T'HH:mm:ss.SSSXXX").parse ( string );
    } catch ( ParseException e ) {
        return Exceptions.handle (Date.class, "Not a valid JSON date", e);
    }


}

PLIST文件（ASCII非GNUNext）也使用ISO 8601，但没有毫秒数，因此...并非所有ISO-8601日期都相同。（至少我还没有找到使用milis的工具，而且我看到的解析器完全跳过了时区OMG）。

现在是快速版本（您可以在Boon中找到它）。

public static Date fromJsonDate( String string ) {

    return fromJsonDate ( Reflection.toCharArray ( string ), 0, string.length () );

}

请注意，Reflection.toCharArray使用不安全（如果可用），但默认使用string.toCharArray。

（您可以通过将Reflection.toCharArray（string）替换为string.toCharArray（）来使它脱离示例）。

public static Date fromJsonDate( char[] charArray, int from, int to ) {

    if (isJsonDate ( charArray, from, to )) {
        int year = CharScanner.parseIntFromTo ( charArray, from + 0, from + 4 );
        int month = CharScanner.parseIntFromTo ( charArray,  from +5,  from +7 );
        int day = CharScanner.parseIntFromTo ( charArray,  from +8,  from +10 );
        int hour = CharScanner.parseIntFromTo ( charArray,  from +11,  from +13 );

        int minute = CharScanner.parseIntFromTo ( charArray,  from +14,  from +16 );

        int second = CharScanner.parseIntFromTo ( charArray,  from +17,  from +19 );

        int miliseconds = CharScanner.parseIntFromTo ( charArray,  from +20,  from +23 );

        TimeZone tz = TimeZone.getTimeZone ( "GMT" );


        return toDate ( tz, year, month, day, hour, minute, second, miliseconds );

    }   else {
        return null;
    }

}

isJsonDate实现如下：

public static boolean isJsonDate( char[] charArray, int start, int to ) {
    boolean valid = true;
    final int length = to -start;

    if (length != JSON_TIME_LENGTH) {
        return false;
    }

    valid &=  (charArray [ start + 19 ]  == '.');

    if (!valid) {
        return false;
    }


    valid &=  (charArray[  start +4 ]  == '-') &&
            (charArray[  start +7 ]  == '-') &&
            (charArray[  start +10 ] == 'T') &&
            (charArray[  start +13 ] == ':') &&
            (charArray[  start +16 ] == ':');

    return valid;
}

无论如何...我的猜测是，来这里的人很多。.可能正在寻找JSON Date String，尽管它是ISO-8601日期，但这是一个非常具体的日期，需要非常具体的解析。

public static int parseIntFromTo ( char[] digitChars, int offset, int to ) {
    int num = digitChars[ offset ] - '0';
    if ( ++offset < to ) {
        num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
        if ( ++offset < to ) {
            num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
            if ( ++offset < to ) {
                num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                if ( ++offset < to ) {
                    num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                    if ( ++offset < to ) {
                        num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                        if ( ++offset < to ) {
                            num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                            if ( ++offset < to ) {
                                num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                                if ( ++offset < to ) {
                                    num = ( num * 10 ) + ( digitChars[ offset ] - '0' );
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return num;
}

请参阅https://github.com/RichardHightower/boon Boon具有PLIST解析器（ASCII）和JSON解析器。

JSON解析器是我所知道的最快的Java JSON解析器。

由加特林性能大佬独立验证。

https://github.com/gatling/json-parsers-benchmark

Benchmark                               Mode Thr     Count  Sec         Mean   Mean error        Units
BoonCharArrayBenchmark.roundRobin      thrpt  16        10    1   724815,875    54339,825    ops/s
JacksonObjectBenchmark.roundRobin      thrpt  16        10    1   580014,875   145097,700    ops/s
JsonSmartBytesBenchmark.roundRobin     thrpt  16        10    1   575548,435    64202,618    ops/s
JsonSmartStringBenchmark.roundRobin    thrpt  16        10    1   541212,220    45144,815    ops/s
GSONStringBenchmark.roundRobin         thrpt  16        10    1   522947,175    65572,427    ops/s
BoonDirectBytesBenchmark.roundRobin    thrpt  16        10    1   521528,912    41366,197    ops/s
JacksonASTBenchmark.roundRobin         thrpt  16        10    1   512564,205   300704,545    ops/s
GSONReaderBenchmark.roundRobin         thrpt  16        10    1   446322,220    41327,496    ops/s
JsonSmartStreamBenchmark.roundRobin    thrpt  16        10    1   276399,298   130055,340    ops/s
JsonSmartReaderBenchmark.roundRobin    thrpt  16        10    1    86789,825    17690,031    ops/s

它具有用于流，读取器，bytes []，char []，CharSequence（StringBuilder，CharacterBuffer）和String的最快的JSON解析器。

#12楼

不幸的是， SimpleDateFormat （Java 6和更早版本）可用的时区格式不符合ISO 8601 。 SimpleDateFormat理解时区字符串，例如“ GMT + 01：00”或“ +0100”，后者根据RFC＃822进行定义。

即使Java 7根据ISO 8601添加了对时区描述符的支持，SimpleDateFormat仍然不能正确解析完整的日期字符串，因为它不支持可选部分。

使用regexp重新格式化输入字符串当然是一种可能，但是替换规则并不像您的问题那么简单：

某些时区的时间不是UTC整小时，因此字符串不一定以“：00”结尾。
ISO8601仅允许时区中包含小时数，因此“ +01”等效于“ +01：00”
ISO8601允许使用“ Z”表示UTC而不是“ +00：00”。

较简单的解决方案可能是在JAXB中使用数据类型转换器，因为JAXB必须能够根据XML Schema规范解析ISO8601日期字符串。 javax.xml.bind.DatatypeConverter.parseDateTime("2010-01-01T12:00:00Z")将为您提供一个Calendar对象，如果您需要Date对象，则可以在其上简单地使用getTime（）。

您可能也可以使用Joda-Time ，但我不知道您为什么要为此烦恼。

#13楼

对于Java版本7

您可以遵循Oracle文档： http : //docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html

X-用于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);

#14楼

java.time

请注意，在Java 8中，可以使用java.time.ZonedDateTime类及其静态parse(CharSequence text)方法。

#15楼

java.time

java.time API （内置在Java 8及更高版本中）使此操作变得容易一些。

如果您知道输入采用UTC格式，例如最后的Z （对于Zulu），则Instant类可以解析。

java.util.Date date = Date.from( Instant.parse( "2014-12-12T10:39:40Z" ));

如果您的输入可能是另一个从UTC偏移的值，而不是最后由Z （Zulu）表示的UTC ，请使用OffsetDateTime类进行解析。

OffsetDateTime odt = OffsetDateTime.parse( "2010-01-01T12:00:00+01:00" );

然后提取一个Instant ，并通过from调用将其转换为java.util.Date 。

Instant instant = odt.toInstant();  // Instant is always in UTC.
java.util.Date date = java.util.Date.from( instant );

#16楼

您也可以使用以下类-

org.springframework.extensions.surf.util.ISO8601DateFormat


Date date = ISO8601DateFormat.parse("date in iso8601");

链接到Java文档- 包org.springframework.extensions.surf.maven.plugin.util的层次结构

#17楼

就像其他人提到的那样，Android没有一个很好的方法来支持使用SDK中包含的类来解析/格式化ISO 8601日期。我已经多次编写了此代码，因此最终创建了一个包含DateUtils类的Gist，该类支持格式化和解析ISO 8601和RFC 1123日期。要点还包括一个测试案例，说明了其支持的内容。

https://gist.github.com/mraccola/702330625fad8eebe7d3

#18楼

我遇到了同样的问题，并通过以下代码解决了该问题。

 public static Calendar getCalendarFromISO(String datestring) {
    Calendar calendar = Calendar.getInstance(TimeZone.getDefault(), Locale.getDefault()) ;
    SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.getDefault());
    try {
        Date date = dateformat.parse(datestring);
        date.setHours(date.getHours() - 1);
        calendar.setTime(date);

        String test = dateformat.format(calendar.getTime());
        Log.e("TEST_TIME", test);

    } catch (ParseException e) {
        e.printStackTrace();
    }

    return calendar;
}

之前我使用过SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.getDefault());

但是后来我发现导致异常的主要原因是yyyy-MM-dd'T'HH:mm:ss.SSSZ ，

所以我用

SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.getDefault());

对我来说很好。

#19楼

我有一个类似的需求：我需要能够解析任何符合ISO8601的日期而无需事先知道确切的格式，并且我想要一个轻量级的解决方案，该解决方案也可以在Android上使用。

当我查询我的需求时，我偶然发现了这个问题，并注意到AFAIU，没有任何答案完全符合我的需求。因此，我开发了jISO8601并将其推向Maven Central 。

只需添加pom.xml ：

<dependency>
  <groupId>fr.turri</groupId>
  <artifactId>jISO8601</artifactId>
  <version>0.2</version>
</dependency>

然后您就可以开始：

import fr.turri.jiso8601.*;
...
Calendar cal = Iso8601Deserializer.toCalendar("1985-03-04");
Date date = Iso8601Deserializer.toDate("1985-03-04T12:34:56Z");

希望对您有所帮助。

#20楼

为了像这样格式化日期，以下代码在基于Java 6的应用程序中为我工作。有一个DateFormat类JacksonThymeleafISO8601DateFormat在其中插入缺失结肠thymeleaf项目：

https://github.com/thymeleaf/thymeleaf/blob/40d27f44df7b52eda47d1bc6f1b3012add6098b3/src/main/java/org/thymeleaf/standard/serializer/StandardJavaScriptSerializer.java

我将其用于ECMAScript日期格式兼容性。

#21楼

像这样做：

public static void main(String[] args) throws ParseException {

    String dateStr = "2016-10-19T14:15:36+08:00";
    Date date = javax.xml.bind.DatatypeConverter.parseDateTime(dateStr).getTime();

    System.out.println(date);

}

这是输出：

2016年10月19日星期三15:15:36 CST

#22楼

Java 7+的解决方法是使用SimpleDateFormat：
DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX", Locale.US);

此代码可以解析ISO8601格式，例如：

2017-05-17T06:01:43.785Z
2017-05-13T02:58:21.391+01:00

但是在Java6上， SimpleDateFormat无法理解X字符，并且会抛出
IllegalArgumentException: Unknown pattern character 'X'
我们需要使用SimpleDateFormat Java 6中可读的格式。

public static Date iso8601Format(String formattedDate) throws ParseException {
    try {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX", Locale.US);
        return df.parse(formattedDate);
    } catch (IllegalArgumentException ex) {
        // error happen in Java 6: Unknown pattern character 'X'
        if (formattedDate.endsWith("Z")) formattedDate = formattedDate.replace("Z", "+0000");
        else formattedDate = formattedDate.replaceAll("([+-]\\d\\d):(\\d\\d)\\s*$", "$1$2");
        DateFormat df1 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.US);
        return df1.parse(formattedDate);
    }
}

当Java 6中发生错误时，上述方法可将[ Z用+0000 ]替换为[ +01:00 +0100 ]（您可以检测Java版本并用if语句替换try / catch）。

#23楼

使用类似LocalDate.parse(((String) data.get("d_iso8601")),DateTimeFormatter.ISO_DATE)

#24楼

Java有许多解析日期时间的方法，如此处的出色答案所示。但是有些令人惊讶的是，Java的时间类都没有完全实现ISO 8601！

对于Java 8，我建议：

ZonedDateTime zp = ZonedDateTime.parse(string);
Date date = Date.from(zp.toInstant());

这将同时处理UTC和偏移量的示例，例如“ 2017-09-13T10：36：40Z”或“ 2017-09-13T10：36：40 + 01：00”。它将适用于大多数用例。

但它不会处理类似“ 2017-09-13T10：36：40 + 01”之类的示例，这是有效的ISO 8601日期时间。
它也不会仅处理日期，例如“ 2017-09-13”。

如果必须处理这些问题，建议您先使用正则表达式来嗅探语法。

这里有一个很好的ISO 8601示例列表，其中包含很多极端情况： https : //www.myintervals.com/blog/2009/05/20/iso-8601-date-validation-that-doesnt-suck/不知道任何可以解决所有问题的Java类。

#25楼

令我惊讶的是，甚至没有一个Java库能够按照https://en.wikipedia.org/wiki/ISO_8601支持所有ISO 8601日期格式。 Joda DateTime支持大多数，但不是全部，因此我添加了自定义逻辑来处理所有这些。这是我的实现。

 import java.text.ParseException; import java.util.Date; import org.apache.commons.lang3.time.DateUtils; import org.joda.time.DateTime; public class ISO8601DateUtils { /** * It parses all the date time formats from https://en.wikipedia.org/wiki/ISO_8601 and returns Joda DateTime. * Zoda DateTime does not support dates of format 20190531T160233Z, and hence added custom logic to handle this using SimpleDateFormat. * @param dateTimeString ISO 8601 date time string * @return */ public static DateTime parse(String dateTimeString) { try { return new DateTime( dateTimeString ); } catch(Exception e) { try { Date dateTime = DateUtils.parseDate(dateTimeString, JODA_NOT_SUPPORTED_ISO_DATES); return new DateTime(dateTime.getTime()); } catch (ParseException e1) { throw new RuntimeException(String.format("Date %s could not be parsed to ISO date", dateTimeString)); } } } private static String[] JODA_NOT_SUPPORTED_ISO_DATES = new String[] { // upto millis "yyyyMMdd'T'HHmmssSSS'Z'", "yyyyMMdd'T'HHmmssSSSZ", "yyyyMMdd'T'HHmmssSSSXXX", "yyyy-MM-dd'T'HHmmssSSS'Z'", "yyyy-MM-dd'T'HHmmssSSSZ", "yyyy-MM-dd'T'HHmmssSSSXXX", // upto seconds "yyyyMMdd'T'HHmmss'Z'", "yyyyMMdd'T'HHmmssZ", "yyyyMMdd'T'HHmmssXXX", "yyyy-MM-dd'T'HHmmss'Z'", "yyyy-MM-dd'T'HHmmssZ", "yyyy-MM-dd'T'HHmmssXXX", // upto minutes "yyyyMMdd'T'HHmm'Z'", "yyyyMMdd'T'HHmmZ", "yyyyMMdd'T'HHmmXXX", "yyyy-MM-dd'T'HHmm'Z'", "yyyy-MM-dd'T'HHmmZ", "yyyy-MM-dd'T'HHmmXXX", //upto hours is already supported by Joda DateTime }; }

#26楼

DatatypeConverter解决方案不适用于所有VM。以下对我有用：

javax.xml.datatype.DatatypeFactory.newInstance().newXMLGregorianCalendar("2011-01-01Z").toGregorianCalendar().getTime()

我发现joda不能开箱即用（特别是我在上面给出的带有日期时区的示例中，这应该是有效的）

#27楼

进行了一个小测试，该测试演示如何在ISO8601中解析日期，并且LocalDateTime不处理DST。

 @Test
    public void shouldHandleDaylightSavingTimes() throws ParseException {

        //ISO8601 UTC date format
        SimpleDateFormat utcFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX");

        // 1 hour of difference between 2 dates in UTC happening at the Daylight Saving Time
        Date d1 = utcFormat.parse("2019-10-27T00:30:00.000Z");
        Date d2 = utcFormat.parse("2019-10-27T01:30:00.000Z");

        //Date 2 is before date 2
        Assert.assertTrue(d1.getTime() < d2.getTime());
        // And there is 1 hour difference between the 2 dates
        Assert.assertEquals(1000*60*60, d2.getTime() - d1.getTime());

        //Print the dates in local time
        SimpleDateFormat localFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm z Z", Locale.forLanguageTag("fr_CH"));
        localFormat.setTimeZone(TimeZone.getTimeZone("Europe/Zurich"));

        //Both dates are at 02h30 local time (because of DST), but one is CEST +0200 and the other CET +0100 (clock goes backwards)
        Assert.assertEquals("2019-10-27 02:30 CEST +0200", localFormat.format(d1));
        Assert.assertEquals("2019-10-27 02:30 CET +0100", localFormat.format(d2));

        //Small test that shows that LocalDateTime does not handle DST (and should not be used for storing timeseries data)
        LocalDateTime ld1 = LocalDateTime.ofInstant(d1.toInstant(), ZoneId.of("Europe/Zurich"));
        LocalDateTime ld2 = LocalDateTime.ofInstant(d2.toInstant(), ZoneId.of("Europe/Zurich"));

        //Note that a localdatetime does not handle DST, therefore the 2 dates are the same
        Assert.assertEquals(ld1, ld2);

        //They both have the following local values
        Assert.assertEquals(2019, ld1.getYear());
        Assert.assertEquals(27, ld1.getDayOfMonth());
        Assert.assertEquals(10, ld1.getMonthValue());
        Assert.assertEquals(2, ld1.getHour());
        Assert.assertEquals(30, ld1.getMinute());
        Assert.assertEquals(0, ld1.getSecond());

    }

#28楼

这是使用Java 7的基于Kotlin的方法。您可以传递自定义模式，也可以仅使用默认的ISO8601模式。但是，您可能需要处理解析错误。

object DateUtil {

    private const val ISO_8601_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSSX"

    fun convertDateToTimestamp(date: Date, pattern: String = ISO_8601_PATTERN): String {
        val df = SimpleDateFormat(pattern, Locale.getDefault()).apply {
            timeZone = TimeZone.getTimeZone("UTC")
        }
        return df.format(date)
    }

    fun convertTimestampToDate(timestamp: String, pattern: String = ISO_8601_PATTERN): Date {
        val formatter = SimpleDateFormat(pattern, Locale.getDefault()).apply {
            timeZone = TimeZone.getTimeZone("UTC")
        }
        return formatter.parse(timestamp) ?: Date(0)
    }
}

p15097962069

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
将符合ISO 8601的字符串转换为java.util.Date

我正在尝试将ISO 8601格式的String转换为java.util.Date 。如果与区域设置（比较示例）一起使用，我发现模式yyyy-MM-dd'T'HH:mm:ssZ符合ISO86
复制链接

扫一扫