java - ISO8601準拠の文字列をjava.util.Dateに変換する

Question

ISO8601形式の文字列をに変換しようとしていjava.util.Dateます。

ロケールで使用した場合、パターンyyyy-MM-dd'T'HH:mm:ssZはISO8601に準拠していることがわかりました（サンプルを比較してください）。

ただし、を使用するjava.text.SimpleDateFormatと、正しくフォーマットされた文字列を変換できません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" ) ;

私にとって、これは素晴らしいことです。

score 505 · Accepted Answer

残念ながら、 SimpleDateFormat（Java 6以前）で使用可能なタイムゾーン形式は、ISO8601に準拠していません。SimpleDateFormatは、「GMT + 01：00」や「+0100」などのタイムゾーン文字列を理解します。後者はRFC＃822に準拠しています。

Java7がISO8601に従ってタイムゾーン記述子のサポートを追加した場合でも、SimpleDateFormatはオプション部分をサポートしていないため、完全な日付文字列を適切に解析できません。

正規表現を使用して入力文字列を再フォーマットすることは確かに1つの可能性ですが、置換ルールは質問のように単純ではありません。

一部のタイムゾーンはUTCから完全に離れていないため、文字列は必ずしも「：00」で終わるとは限りません。
ISO8601では、タイムゾーンに含めることができる時間数のみが許可されているため、「+ 01」は「+01：00」と同等です。
ISO8601では、「+ 00：00」の代わりに「Z」を使用してUTCを示すことができます。

JAXBはXMLスキーマ仕様に従ってISO8601日付文字列を解析できる必要があるため、より簡単な解決策は、JAXBでデータ型コンバーターを使用することです。javax.xml.bind.DatatypeConverter.parseDateTime("2010-01-01T12:00:00Z")オブジェクトが提供され、オブジェクトCalendarが必要な場合は、getTime（）を使用できDateます。

おそらくJoda-Timeも使用できますが、なぜそれを気にする必要があるのかわかりません。

score 292 · Accepted Answer

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の例のセクションで、より多くの例を見つけることができます。

UPD 02/13/2020：Java8でこれを行うためのまったく新しい方法があります

score 207 · Accepted Answer

さて、この質問はすでに回答済みですが、とにかく回答を削除します。それは誰かを助けるかもしれません。

私はAndroid（API 7）のソリューションを探していました。

Jodaは問題外でした-それは巨大で、初期化が遅いという問題があります。それはまた、その特定の目的のための主要なやり過ぎのようでした。
関係する回答javax.xmlはAndroidAPI7では機能しません。

この単純なクラスを実装することになりました。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;
    }
}

パフォーマンスに関する注意： Android 2.1のバグを回避する手段として、毎回新しいSimpleDateFormatをインスタンス化します。あなたが私と同じように驚いているなら、このなぞなぞを見てください。他のJavaエンジンの場合、インスタンスをプライベート静的フィールドにキャッシュできます（スレッドセーフにするために、ThreadLocalを使用します）。

score 138 · Accepted Answer

java.time

java.time API（Java 8以降に組み込まれている）を使用すると、これが少し簡単になります。

最後の（Zuluの）など、入力がUTCであることがわかっている場合、クラスは解析できます。ZInstant

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

入力が、最後に（Zulu）で示されるUTCではなくUTCからの別のオフセット値である可能性がある場合は、クラスを使用して解析します。ZOffsetDateTime

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

次に、を抽出し、を呼び出しInstantてに変換します。java.util.Datefrom

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

score 74 · Accepted Answer

74

于 2013-12-14T01:48:16.813 に答える

score 72 · Accepted Answer

Jackson-databindライブラリには、それを行う ISO8601DateFormatクラスもあります（ISO8601Utilsでの実際の実装）。

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

score 57 · Accepted Answer

Java 8以降、これを行うための完全に新しい公式にサポートされている方法があります。

    String s = "2020-02-13T18:51:09.840Z";
    TemporalAccessor ta = DateTimeFormatter.ISO_INSTANT.parse(s);
    Instant i = Instant.from(ta);
    Date d = Date.from(i);

score 35 · Accepted Answer

Javaバージョン7の場合

Oracleのドキュメントに従うことができます：http： //docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html

X-ISO8601タイムゾーンに使用されます

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

score 23 · Accepted Answer

DatatypeConverterソリューションは、すべてのVMで機能するわけではありません。以下は私のために働きます：

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

jodaはそのままでは機能しないことがわかりました（特に、上記の例では、有効な日付のタイムゾーンを使用しています）

score 14 · Accepted Answer

使うべきだと思います

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

日付2010-01-01T12:00:00Z

score 10 · Accepted Answer

ISO8601タイムスタンプを解析するもう1つの非常に簡単な方法は、次を使用すること 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());
  }
}

score 10 · Accepted Answer

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理解せず、スローされます。ISO8601の日付をJava6で読み取り可能な形式に正規化する必要があります。X
IllegalArgumentException: Unknown pattern character 'X'
SimpleDateFormat

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でエラーが発生したときに[ Zwith +0000]または[ +01:00with ]を置き換えます（Javaバージョンを検出し、try / catchをifステートメントに置き換えることができます）。+0100

score 8 · Accepted Answer

ISO8601を現在までに変換するために多くの検索を行った後、突然ISO8601Util.javaというJavaクラスが見つかりました。これは、 com.google.gson.internal.bind.utilの一部でした。したがって、これを使用して日付を変換できます。

ISO8601Utils.parse("2010-01-01T12:00:00Z" , ParsePosition(0))

このkotlin拡張機能を簡単に使用できます

fun String.getDateFromString() : Date? = ISO8601Utils.parse(this , 
ParsePosition(0))

score 7 · Accepted Answer

Java8以降

私が答えで見つけられなかった単純な1つのライナー：

Date date = Date.from(ZonedDateTime.parse("2010-01-01T12:00:00+01:00").toInstant());

日付にはタイムゾーンが含まれていません。UTCで保存されますが、。を使用した単純な出力中でも、JVMタイムゾーンに適切に変換されますSystem.out.println(date)。

score 6 · Accepted Answer

java.time

Java 8では、 java.time.ZonedDateTimeクラスとその静的メソッドを使用できることに注意してくださいparse(CharSequence text)。

score 6 · Accepted Answer

私は同じ問題に直面し、次のコードでそれを解決しました。

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

それは私にとってはうまくいきました。

score 6 · Accepted Answer

ここでの優れた回答が示すように、Javaには日時を解析するための12の異なる方法があります。しかし、驚くべきことに、JavaのタイムクラスはどれもISO8601を完全に実装していません。

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」のようなオフセットの両方で例を処理します。ほとんどのユースケースで機能します。

ただし、有効なISO 8601日時である「2017-09-13T10：36：40+01」のような例は処理されません。
また、日付のみを処理しません（例：「2017-09-13」）。

それらを処理する必要がある場合は、最初に正規表現を使用して構文をスニッフィングすることをお勧めします。

ここに多くのコーナーケースを含むISO8601の例の素晴らしいリストがあります：https ：//www.myintervals.com/blog/2009/05/20/iso-8601-date-validation-that-doesnt-suck/私はそれらすべてに対処できるJavaクラスを認識していません。

score 5 · Accepted Answer

また、次のクラスを使用できます-

org.springframework.extensions.surf.util.ISO8601DateFormat


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

JavaDocへのリンク-パッケージの階層org.springframework.extensions.surf.maven.plugin.util

score 3 · Accepted Answer

他の人が述べているように、Androidには、SDKに含まれているクラスを使用したISO8601日付の解析/フォーマットをサポートする良い方法がありません。このコードを何度も書いたので、ISO8601とRFC1123の日付のフォーマットと解析をサポートするDateUtilsクラスを含むGistを最終的に作成しました。Gistには、サポート内容を示すテストケースも含まれています。

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

score 2 · Accepted Answer

SimpleDateFormat for JAVA 1.7には、ISO8601形式のクールなパターンがあります。

クラスSimpleDateFormat

これが私がしたことです：

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

score 2 · Accepted Answer

次のような文字列を使用します LocalDate.parse(((String) data.get("d_iso8601")),DateTimeFormatter.ISO_DATE)

score 2 · Accepted Answer

https://en.wikipedia.org/wiki/ISO_8601のように、1つのJavaライブラリでもすべてのISO8601日付形式をサポートしているわけではないことに驚いています。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
	};
}

score 1 · Accepted Answer

このようにしてください：

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:36CST

score 1 · Accepted Answer

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

    }

score 1 · Accepted Answer

UTCから必要な形式に変換する場合。滞在するゾーン/場所によって変わります

//utcDate = "2021-06-05T02:46:29Z"
fun converterUtcToReadableDateTime(utcDate: String): String {
    val offsetDateTime = OffsetDateTime.ofInstant(Instant.parse(utcDate), ZoneId.systemDefault())
    val patternDate = "dd MMM yyyy h:mm a"
    return DateTimeFormatter.ofPattern(patternDate).format(offsetDateTime)
}

fun converterUtcToReadableDate(utcDate: String): String {
    val offsetDateTime = OffsetDateTime.ofInstant(Instant.parse(utcDate), ZoneId.systemDefault())
    val patternDate = "d MMM yyyy"
    return DateTimeFormatter.ofPattern(patternDate).format(offsetDateTime)
}

fun converterUtcToReadableTime(utcDate: String): String {
    val offsetDateTime = OffsetDateTime.ofInstant(Instant.parse(utcDate), ZoneId.systemDefault())
    val patternDate = "h:mm a"
    return DateTimeFormatter.ofPattern(patternDate).format(offsetDateTime)
}

score 0 · Accepted Answer

同様のニーズがありました。正確な形式を事前に知らなくても、ISO8601に準拠した日付を解析できる必要があり、Androidでも機能する軽量のソリューションが必要でした。

私が自分のニーズをグーグルで検索したとき、私はこの質問に出くわし、AFAIUに気づきました。私のニーズに完全に一致する答えはありません。そこで、jISO8601を開発し、 MavenCentralにプッシュしました。

あなたを追加するだけです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");

お役に立てば幸いです。

score 0 · Accepted Answer

このように日付をフォーマットするだけで、Java6ベースのアプリケーションで次のことがうまくいきました。thymeleafプロジェクトには、欠落しているコロンを挿入するDateFormatクラスがあります。JacksonThymeleafISO8601DateFormat

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

ECMAScriptの日付形式の互換性のために使用しました。

score -1 · Accepted Answer

基本機能の礼儀：@wrygiel。

この関数は、ISO8601形式をオフセット値を処理できるJava日付に変換できます。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文字列
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;
}

}

score -2 · Accepted Answer

多くの人がやりたいのはJSONの日付文字列を解析することだと思います。このページにアクセスした場合、JavaScriptJSONの日付を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);
}

私は自分のプロジェクトでこれを行うために2つの方法を書きました。1つの標準、1つの高速。

繰り返しますが、JSON日付文字列はISO8601の非常に特殊な実装です...。

（私は、別のISO 8601形式であるPLIST日付で機能するはずの別の回答にもう1つを投稿しました）。

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日付文字列を探している可能性があります。これは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パーサーは、私が知っている最速のJavaJSONパーサーです。

ガトリングパフォーマンスの男によって独立して検証されました。

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

java - ISO8601準拠の文字列をjava.util.Dateに変換する

29 に答える 29

java.time

java.time

Related

Reference