日期对象SimpleDataFormat在Java（Android）环境中未正确解析时间戳字符串

我将

SimpleDateFormat

对象与

Date

对象一起使用，如下所示。问题在于

Date

对象显示的日期错误，与原始字符串相差几分钟。

Date

对象将在调试器中以毫秒为单位存储时间

对这个问题有什么想法吗

import java.text.SimpleDateFormat;

import java.util.Date;

Date played_at_local; 

dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.SSSSSSZ");

played_at_local = dateFormat.parse("2011-04-11T22:27:18.491726-05:00"); 

//played_at_local shows "Mon Apr 11 22:35:29 America/Chicago 2011" in debugger

05:00-->>0500

及

hh-->hh//错误不是因为这个，而是日期是24小时格式。

played_at_local = dateFormat.parse("2011-04-11T22:27:18.491726-05:00"); 

应该是

played_at_local = dateFormat.parse("2011-04-11T22:27:18.491726-0500"); 

---

试试这个，为我工作Z应该在日期中使用，或者从格式字符串中移动

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss.SSSSSS'Z'");

played_at_local = dateFormat.parse("2011-04-11T22:27:18.491726Z-05:00");

---

尝试从格式字符串中删除小数秒。我只是遇到了同样的问题，但格式略有不同。我的输入格式不是ISO格式（没有“t”，也没有“Z”），但症状是一样的——时间以随机的分秒数缩短，但其他一切都很好。以下是我的日志结果：

使用分数秒格式时：

SimpleDateFormat dateFormater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSSSS");

# Parsed date: 2011-05-27 17:11:15.271816 => Fri May 27 17:15:46 EDT 2011
# Parsed date: 2011-05-27 17:09:37.750343 => Fri May 27 17:22:07 EDT 2011
# Parsed date: 2011-05-27 17:05:55.182921 => Fri May 27 17:08:57 EDT 2011
# Parsed date: 2011-05-27 16:55:05.69092 => Fri May 27 16:56:14 EDT 2011
# Parsed date: 2011-05-27 16:38:35.50348 => Fri May 27 16:39:25 EDT 2011

我通过删除格式中的小数秒来修复它

SimpleDateFormat dateFormater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

# Parsed date: 2011-05-27 17:11:15.271816 => Fri May 27 17:11:15 EDT 2011
# Parsed date: 2011-05-27 17:09:37.750343 => Fri May 27 17:09:37 EDT 2011
# Parsed date: 2011-05-27 17:05:55.182921 => Fri May 27 17:05:55 EDT 2011
# Parsed date: 2011-05-27 16:55:05.69092 => Fri May 27 16:55:05 EDT 2011
# Parsed date: 2011-05-27 16:38:35.50348 => Fri May 27 16:38:35 EDT 2011

---

我认为正在发生的是，输入字符串的“分数秒”部分太长（OP示例中也是如此）。它似乎只需要三位小数位。如果您进行计算（以第一个示例为例）：

• 分数秒=0.271816秒
• DateFormat看到的是一秒钟的

  271816/1000

• 271816/1000==271秒
• 271/60=4分钟
• 271%60=31秒
• 17:11:15到17:15:46正好是4分31秒

---

您可以尝试以下方法：

关键是小数位数是可选的，您可以使用数量可变的小数位数。然而，这似乎不能解释时区

从文档中：

valueOf

public static Timestamp valueOf(String s)
Converts a String object in JDBC timestamp escape format to a Timestamp value.
Parameters:
s - timestamp in format yyyy-mm-dd hh:mm:ss[.f...]. The fractional seconds may be omitted.
Returns:
corresponding Timestamp value
Throws:
IllegalArgumentException - if the given argument does not have the format yyyy-mm-dd hh:mm:ss[.f...]

试试这个：

dTime  =  new  SimpleDateFormat("HH:mm:ss:SS");
String  sTime =  (dTime.format(new java.util.Date())).toString();

希望这有帮助

java.time和ThreeTenABP

SimpleDateFormat

无法正确解析日期时间字符串。另一方面，现代java日期和时间API java.time支持开箱即用的格式

import org.threeten.bp.OffsetDateTime;

    String dateTimeString = "2011-04-11T22:27:18.491726-05:00";
    OffsetDateTime playedAtLocal = OffsetDateTime.parse(dateTimeString);
    System.out.println("Parsed into " + playedAtLocal);

输出为：

解析为2011-04-11T22:27:18.491726-05:00

SimpleDateFormat

只支持毫秒，秒数正好是三位小数，不是两位小数，不是四位小数，不是六位小数（诚然，我不确定一些Android版本是否有一个版本的

SimpleDateFormat

可以做得更好，但你的问题表明你的版本不能）

SimpleDataFormat

也是出了名的麻烦和过时，所以您无论如何都不想使用它

使用java.time更方便。您注意到，我们甚至不需要显式的格式化程序，因此不需要编写格式模式字符串，这总是一项容易出错的任务。日期时间字符串采用ISO 8601格式，java.time类将ISO 8601解析为其默认值

问题：我可以在Android上使用java.time吗？ 是的，java.time在较旧和较新的Android设备上运行良好。它至少需要Java6

• 在Java8和更高版本以及更新的Android设备上（API级别26），现代API是内置的
• 在Java6和Java7中，获取三个后端口，即现代类的后端口（三个十用于JSR310；参见底部的链接）
• 在（较旧的）Android上使用Android版本的ThreeTen Backport。它叫ThreeTenABP。并确保从带有子包的

  org.threeten.bp

  导入日期和时间类

链接

• 解释如何使用java.time
• ，其中首先描述了

  java.time

• ，java.time的后端口到Java6和Java7（JSR-310为三十）
• ，Android版Three Ten Backport
• ，解释得非常透彻

---

代码中有三个主要问题：

您使用

.sssss

的时间仅为几分之一秒，而

SimpleDataFormat

不支持超过毫秒的精度（

.SSS

）。这也意味着您需要将数字限制在一秒的小数点到三

您已经使用了

Z

来解析时区偏移量，

-05:00

，而用于此的是

XXX

您已经使用了24小时格式的

hh

一段时间，而正确的模式是

hh

。符号

hh

用于12小时（即am/pm）格式的时间

除此之外，我建议您始终将

Locale

与日期解析/格式化API一起使用，因为日期时间字符串的部分在不同的

Locale

s中以不同的方式表示

演示：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;

public class Main {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.ENGLISH);
        Date date = sdf.parse("2011-04-11T22:27:18.491-05:00");

        // Print the default string i.e. Date#toString
        System.out.println(date);

        // Print the date-time in a custom format
        sdf.setTimeZone(TimeZone.getTimeZone("GMT-05:00"));
        System.out.println(sdf.format(date));
    }
}

Tue Apr 12 04:27:18 BST 2011
2011-04-11T22:27:18.491-05:00

import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        OffsetDateTime odt = OffsetDateTime.parse("2011-04-11T22:27:18.491726-05:00");

        // Print the default string i.e. OffsetDateTime#toString
        System.out.println(odt);

        // Print the date-time in a custom format. Note: OffsetDateTime#toString drops
        // seconds if it is zero
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss.SSSSSSXXX");
        System.out.println(dtf.format(odt));
    }
}

2011-04-11T22:27:18.491726-05:00
2011-04-11T22:27:18.491726-05:00

输出：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;

public class Main {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.ENGLISH);
        Date date = sdf.parse("2011-04-11T22:27:18.491-05:00");

        // Print the default string i.e. Date#toString
        System.out.println(date);

        // Print the date-time in a custom format
        sdf.setTimeZone(TimeZone.getTimeZone("GMT-05:00"));
        System.out.println(sdf.format(date));
    }
}

Tue Apr 12 04:27:18 BST 2011
2011-04-11T22:27:18.491-05:00

import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        OffsetDateTime odt = OffsetDateTime.parse("2011-04-11T22:27:18.491726-05:00");

        // Print the default string i.e. OffsetDateTime#toString
        System.out.println(odt);

        // Print the date-time in a custom format. Note: OffsetDateTime#toString drops
        // seconds if it is zero
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss.SSSSSSXXX");
        System.out.println(dtf.format(odt));
    }
}

2011-04-11T22:27:18.491726-05:00
2011-04-11T22:27:18.491726-05:00

关于遗留日期时间API的一些事实：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;

public class Main {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.ENGLISH);
        Date date = sdf.parse("2011-04-11T22:27:18.491-05:00");

        // Print the default string i.e. Date#toString
        System.out.println(date);

        // Print the date-time in a custom format
        sdf.setTimeZone(TimeZone.getTimeZone("GMT-05:00"));
        System.out.println(sdf.format(date));
    }
}

Tue Apr 12 04:27:18 BST 2011
2011-04-11T22:27:18.491-05:00

import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        OffsetDateTime odt = OffsetDateTime.parse("2011-04-11T22:27:18.491726-05:00");

        // Print the default string i.e. OffsetDateTime#toString
        System.out.println(odt);

        // Print the date-time in a custom format. Note: OffsetDateTime#toString drops
        // seconds if it is zero
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss.SSSSSSXXX");
        System.out.println(dtf.format(odt));
    }
}

2011-04-11T22:27:18.491726-05:00
2011-04-11T22:27:18.491726-05:00

java.util.Date

对象不像；相反，它表示自称为“历元”的标准基准时间（即1970年1月1日00:00:00 GMT）起的毫秒数。当您打印

java.util.Date

的对象时，其

toString

方法返回JVM时区中的日期时间，从该毫秒值计算得出。如果需要在不同的时区中打印日期时间，则需要将时区设置为

SimpleDateFormat

，并从中获取格式化字符串

java.util

date-time API及其格式化API

SimpleDataFormat

已经过时，并且容易出错。建议完全停止使用，并切换到*

使用现代日期时间API:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;

public class Main {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.ENGLISH);
        Date date = sdf.parse("2011-04-11T22:27:18.491-05:00");

        // Print the default string i.e. Date#toString
        System.out.println(date);

        // Print the date-time in a custom format
        sdf.setTimeZone(TimeZone.getTimeZone("GMT-05:00"));
        System.out.println(sdf.format(date));
    }
}

Tue Apr 12 04:27:18 BST 2011
2011-04-11T22:27:18.491-05:00

import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        OffsetDateTime odt = OffsetDateTime.parse("2011-04-11T22:27:18.491726-05:00");

        // Print the default string i.e. OffsetDateTime#toString
        System.out.println(odt);

        // Print the date-time in a custom format. Note: OffsetDateTime#toString drops
        // seconds if it is zero
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss.SSSSSSXXX");
        System.out.println(dtf.format(odt));
    }
}

2011-04-11T22:27:18.491726-05:00
2011-04-11T22:27:18.491726-05:00

输出：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;

public class Main {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.ENGLISH);
        Date date = sdf.parse("2011-04-11T22:27:18.491-05:00");

        // Print the default string i.e. Date#toString
        System.out.println(date);

        // Print the date-time in a custom format
        sdf.setTimeZone(TimeZone.getTimeZone("GMT-05:00"));
        System.out.println(sdf.format(date));
    }
}

Tue Apr 12 04:27:18 BST 2011
2011-04-11T22:27:18.491-05:00

import java.time.OffsetDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    public static void main(String[] args) {
        OffsetDateTime odt = OffsetDateTime.parse("2011-04-11T22:27:18.491726-05:00");

        // Print the default string i.e. OffsetDateTime#toString
        System.out.println(odt);

        // Print the date-time in a custom format. Note: OffsetDateTime#toString drops
        // seconds if it is zero
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("uuuu-MM-dd'T'HH:mm:ss.SSSSSSXXX");
        System.out.println(dtf.format(odt));
    }
}

2011-04-11T22:27:18.491726-05:00
2011-04-11T22:27:18.491726-05:00

注意：对于，符号，

u

表示年，而