我正在尝试将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
#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楼
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格式具有很酷的模式。
这是我所做的:
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解析器。
在以下位置查看更多基准测试:
https://github.com/RichardHightower/json-parsers-benchmark
#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项目:
我将其用于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)
}
}