Java 字符串到日期的转换

Question

将“2010 年 1 月 2 日”格式的 String 转换为 Java 中的 Date 的最佳方法是什么？

最终，我想将月、日和年分解为整数，以便我可以

Date date = new Date();
date.setMonth()..
date.setYear()..
date.setDay()..
date.setlong currentTime = date.getTime();

将日期转换为时间。

Answer 1

这是一个艰难的方法，并且自 Java 1.1 (1997) 以来，那些 java.util.Date setter 方法已被弃用。此外，自从 Java 8 (2014) 中引入 java.time API 以来，整个 java.util.Date 类实际上已被弃用（不推荐）。

只需使用 DateTimeFormatter 具有与输入字符串匹配的模式 (教程可在此处获取）。

在“January 2, 2010”作为输入字符串的特定情况下：

1. “January”是全文月份，因此请使用 MMMM 模式，
2. “2”是短的月份日期，因此请使用 d 模式。
3. “2010”是 4 位数的年份，因此请使用 yyyy 模式。

String string = "January 2, 2010";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse(string, formatter);
System.out.println(date); // 2010-01-02

注意：如果您的格式模式恰好也包含时间部分，则使用 LocalDateTime#parse(text, formatter) 而不是LocalDate#parse(text, formatter)。而且，如果您的格式模式恰好也包含时区，请使用 ZonedDateTime#parse(text, formatter) 代替。

以下是 javadoc，列出所有可用的格式模式：

符号	含义	表示	示例
G	时代	文本	AD；公元;
u	年	2004年	； 04
y	年	2004年	； 04
D	年份	数字	189
M/L	月份	数字/文本	7; 07;七月;七月; J
d	月份中的日期	数字	10
Q/q	季度	数字/文本	3； 03; Q3； 1996 年第三季度
Y	按周计算的	年份	； 96
w	基于年份的周	数	27
W	月中的周	数	4
E	周中的某天	文本	Tue ;周二; T
e/c	本地化星期几	数字/文本	2； 02;周二；周二; T
F	月份中的星期	数	3
a	am-pm-of-day	文本	PM
h	时钟小时-of-am-pm (1-12)	数字	12
K	上午下午 (0-11)	数字	0
k	时钟上午下午 (1-24) )	数字	0
H	一天中的小时 (0-23)	数字	0
m	小时中的分钟	数字	30
s	秒-分钟	数字	55
S	秒小数部分	978
A	毫秒	数字	1234
n	纳秒	数字	987654321
N	纳秒	数	1234000000
V	时区 ID	zone-id	America/Los_Angeles； Z; -08:30
z	时区名称	zone-name	太平洋标准时间； PST
O	本地化区域偏移	offset-O	GMT+8；格林尼治标准时间+08:00； UTC-08:00；
X	zone-offset 'Z' 零	偏移-X	Z； -08; -0830； -08:30； -083015； -08:30:15；
x	区域偏移	offset-x	+0000; -08; -0830； -08:30； -083015； -08:30:15；
Z	区域偏移	offset-Z	+0000; -0800； -08:00；

请注意，它有几个 针对更流行的模式的预定义格式化程序。因此，您可以使用 DateTimeFormatter.RFC_1123_DATE_TIME，而不是 DateTimeFormatter.ofPattern("EEE, d MMM yyyy HH:mm:ss Z", Locale.ENGLISH);。这是可能的，因为与 SimpleDateFormat 相反，它们是线程安全的。因此，如果有必要，您也可以定义自己的。

对于特定的输入字符串格式，您不需要使用显式的 DateTimeFormatter：标准的 ISO 8601 日期，如 2016-09-26T17:44:57Z，可以直接使用 LocalDateTime#parse(text) 因为它已经使用 ISO_LOCAL_DATE_TIME 格式化程序。同样， LocalDate#parse(text) 解析不带时间部分的 ISO 日期（请参阅 ISO_LOCAL_DATE) 和 ZonedDateTime#parse(text) 解析添加了偏移量和时区的 ISO 日期（请参阅 ISO_ZONED_DATE_TIME）。

---

Java 8 之前的版本

如果您尚未使用 Java 8，或者被迫使用 java.util.Date，请使用 SimpleDateFormat 使用格式模式匹配输入字符串。

String string = "January 2, 2010";
DateFormat format = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH);
Date date = format.parse(string);
System.out.println(date); // Sat Jan 02 00:00:00 GMT 2010

请注意显式 Locale 参数的重要性。如果省略它，它将使用 默认区域设置 不一定是输入字符串的月份名称中使用的英语。如果区域设置与输入字符串不匹配，那么即使格式模式看起来有效，您也会混淆地得到 java.text.ParseException 。

以下是 javadoc，列出所有可用的格式模式：

字母	日期或时间 组件	表示	示例
G	时代指示符	文本	AD
y	年	Year	1996； 96
Y	周	2009年	； 09
M/L	一年中的月份	月份	七月；七月; 07
w	一年中的第几周	数字	27
W	每月中的第几周	数字	2
D	一年中的某天	数字	189
d	某月中的某天月份	数字	10
F	月份中的星期几	数字	2
E	星期中的某天	Text	Tuesday; Tue
u	星期几	数字	1
a	Am/pm 标记	文本	PM
H	一天中的小时 (0-23)	数字	0
k	一天中的小时 (1-24)	数字	24
K	am/pm 小时 (0-11)	数字	0
h	am/pm 小时 (1 -12)	数字	12
m	小时中的分钟	数字	30
s	分钟中的秒	数字	55
S	毫秒	数字	978
z	时区	一般时区	太平洋标准时间；太平洋标准时间; GMT-08:00
Z	时区	RFC 822 时区	-0800
X	时区	ISO 8601 时区	-08； -0800； -08:00

请注意，模式区分大小写，并且基于文本的四个字符或更多字符的模式代表完整形式；否则，如果有的话，将使用简短或缩写的形式。因此，例如 MMMMM 或更多内容是不必要的。

以下是解析迄今为止给定字符串的有效 SimpleDateFormat 模式的一些示例：

输入字符串	模式
2001.07.04 AD at 12:08:56 PDT	yyyy.MM.dd G 'at' HH :mm:ss z
01 年 7 月 4 日星期三	EEE, MMM d, ''yy
12:08 PM	h:mm a
12 点太平洋夏令时间下午	hh 'o''clock' a, zzzz
下午 0:08，太平洋夏令时间	K:mm a, z
02001.July.04 AD 12:08 PM	yyyyy.MMMM.dd GGG hh:mm aaa
2001 年 7 月 4 日星期三 12:08:56 -0700	EEE, d MMM yyyy HH:mm:ss Z
010704120856- 0700	yyMMddHHmmssZ
2001-07-04T12:08:56.235-0700	yyyy-MM-dd'T'HH:mm:ss.SSSZ 2001-07-04T12
:08: 56.235-07:00	yyyy-MM-dd'T'HH:mm:ss.SSSXXX
2001-W27-3	YYYY-'W'ww-u

重要说明是 SimpleDateFormat 是不是线程安全的。换句话说，您永远不应该将其声明并分配为静态变量或实例变量，然后从不同的方法/线程中重用它。您应该始终在方法本地范围内创建全新的它。

Answer 2

啊，是的，再次讨论 Java Date。为了处理日期操作，我们使用 Date, 日历, GregorianCalendar 和 SimpleDateFormat。例如，使用您的一月日期作为输入：

Calendar mydate = new GregorianCalendar();
String mystring = "January 2, 2010";
Date thedate = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH).parse(mystring);
mydate.setTime(thedate);
//breakdown
System.out.println("mydate -> "+mydate);
System.out.println("year   -> "+mydate.get(Calendar.YEAR));
System.out.println("month  -> "+mydate.get(Calendar.MONTH));
System.out.println("dom    -> "+mydate.get(Calendar.DAY_OF_MONTH));
System.out.println("dow    -> "+mydate.get(Calendar.DAY_OF_WEEK));
System.out.println("hour   -> "+mydate.get(Calendar.HOUR));
System.out.println("minute -> "+mydate.get(Calendar.MINUTE));
System.out.println("second -> "+mydate.get(Calendar.SECOND));
System.out.println("milli  -> "+mydate.get(Calendar.MILLISECOND));
System.out.println("ampm   -> "+mydate.get(Calendar.AM_PM));
System.out.println("hod    -> "+mydate.get(Calendar.HOUR_OF_DAY));

然后您可以使用以下内容进行操作：

Calendar now = Calendar.getInstance();
mydate.set(Calendar.YEAR,2009);
mydate.set(Calendar.MONTH,Calendar.FEBRUARY);
mydate.set(Calendar.DAY_OF_MONTH,25);
mydate.set(Calendar.HOUR_OF_DAY,now.get(Calendar.HOUR_OF_DAY));
mydate.set(Calendar.MINUTE,now.get(Calendar.MINUTE));
mydate.set(Calendar.SECOND,now.get(Calendar.SECOND));
// or with one statement
//mydate.set(2009, Calendar.FEBRUARY, 25, now.get(Calendar.HOUR_OF_DAY), now.get(Calendar.MINUTE), now.get(Calendar.SECOND));
System.out.println("mydate -> "+mydate);
System.out.println("year   -> "+mydate.get(Calendar.YEAR));
System.out.println("month  -> "+mydate.get(Calendar.MONTH));
System.out.println("dom    -> "+mydate.get(Calendar.DAY_OF_MONTH));
System.out.println("dow    -> "+mydate.get(Calendar.DAY_OF_WEEK));
System.out.println("hour   -> "+mydate.get(Calendar.HOUR));
System.out.println("minute -> "+mydate.get(Calendar.MINUTE));
System.out.println("second -> "+mydate.get(Calendar.SECOND));
System.out.println("milli  -> "+mydate.get(Calendar.MILLISECOND));
System.out.println("ampm   -> "+mydate.get(Calendar.AM_PM));
System.out.println("hod    -> "+mydate.get(Calendar.HOUR_OF_DAY));

Answer 3

String str_date = "11-June-07";
DateFormat formatter = new SimpleDateFormat("dd-MMM-yy");
Date date = formatter.parse(str_date);

Answer 4

在 Java 8 中，我们获得了新的日期/时间 API (JSR 310)。

在 Java 8 中可以使用以下方式解析日期，而不依赖 Joda-Time：

 String str = "January 2nd, 2010";

---

// if we 2nd even we have changed in pattern also it is not working please workout with 2nd 
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM Q, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse(str, formatter);

---

// access date fields
int year = date.getYear(); // 2010
int day = date.getDayOfMonth(); // 2
Month month = date.getMonth(); // JANUARY
int monthAsInt = month.getValue(); // 1

---

LocalDate 是用于表示的标准 Java 8 类一个日期（没有时间）。如果要解析包含日期和时间信息的值，应使用 本地日期时间。对于带有时区的值，请使用 ZonedDateTime。两者都提供类似于 LocalDate 的 parse() 方法：

LocalDateTime dateWithTime = LocalDateTime.parse(strWithDateAndTime, dateTimeFormatter);
ZonedDateTime zoned = ZonedDateTime.parse(strWithTimeZone, zoneFormatter);

来自 DateTimeFormatter Javadoc：

All letters 'A' to 'Z' and 'a' to 'z' are reserved as pattern letters. 
The following pattern letters are defined:

Symbol  Meaning                     Presentation      Examples
------  -------                     ------------      -------
 G       era                         text              AD; Anno Domini; A
 u       year                        year              2004; 04
 y       year-of-era                 year              2004; 04
 D       day-of-year                 number            189
 M/L     month-of-year               number/text       7; 07; Jul; July; J
 d       day-of-month                number            10

 Q/q     quarter-of-year             number/text       3; 03; Q3; 3rd quarter
 Y       week-based-year             year              1996; 96
 w       week-of-week-based-year     number            27
 W       week-of-month               number            4
 E       day-of-week                 text              Tue; Tuesday; T
 e/c     localized day-of-week       number/text       2; 02; Tue; Tuesday; T
 F       week-of-month               number            3

 a       am-pm-of-day                text              PM
 h       clock-hour-of-am-pm (1-12)  number            12
 K       hour-of-am-pm (0-11)        number            0
 k       clock-hour-of-am-pm (1-24)  number            0

 H       hour-of-day (0-23)          number            0
 m       minute-of-hour              number            30
 s       second-of-minute            number            55
 S       fraction-of-second          fraction          978
 A       milli-of-day                number            1234
 n       nano-of-second              number            987654321
 N       nano-of-day                 number            1234000000

 V       time-zone ID                zone-id           America/Los_Angeles; Z; -08:30
 z       time-zone name              zone-name         Pacific Standard Time; PST
 O       localized zone-offset       offset-O          GMT+8; GMT+08:00; UTC-08:00;
 X       zone-offset 'Z' for zero    offset-X          Z; -08; -0830; -08:30; -083015; -08:30:15;
 x       zone-offset                 offset-x          +0000; -08; -0830; -08:30; -083015; -08:30:15;
 Z       zone-offset                 offset-Z          +0000; -0800; -08:00;

Answer 5

虽然有些答案在技术上是正确的，但并不可取。

• java.util.Date &日历类是出了名的麻烦。由于设计和实现中存在缺陷，请避免它们。幸运的是，我们可以选择另外两个优秀的日期时间库：
  • Joda-Time
    这个流行的开放-源免费库可以在多个 Java 版本中使用。 StackOverflow 上可以找到许多其用法示例。阅读其中一些内容将有助于您快速上手。
  • java.time.* 包< /a>
    这组新的类受到 Joda-Time 的启发并由 JSR 310 定义。这些类内置于 Java 8 中。一个项目正在进行中，旨在将这些类向后移植到 Java 7，但该向后移植不受 Oracle 支持。

  
  

• 正如克里斯托弗·约翰逊在对该问题的评论中正确指出的那样，其他答案忽略了以下重要问题：
  • 时间
    日期同时包含日期部分和时间部分）
  • 时区
    一天的开始取决于时区。如果未能指定时区，则应用 JVM 的默认时区。这意味着在其他计算机上运行或修改时区设置时，代码的行为可能会发生变化。可能不是你想要的。
  • 区域设置
    区域设置的语言指定如何解释解析过程中遇到的单词（月份和日期的名称）。 （BalusC 的回答正确处理了这个问题。）此外，在生成字符串表示形式时，区域设置会影响某些格式化程序的输出您的日期时间。

Joda-Time

下面是有关 Joda-Time 的一些注释。

时区

在 Joda-Time 中，DateTime 对象确实知道自己指定的时区。这与 java.util.Date 类形成鲜明对比，后者似乎有时区，但实际上没有。

请注意下面的示例代码中我们如何将时区对象传递给解析字符串的格式化程序。该时区用于将该日期时间解释为发生在该时区。因此，您需要考虑并确定该字符串输入表示的时区。

由于输入字符串中没有时间部分，Joda-Time 会将指定时区的第一时刻指定为当天的时间。通常这意味着 00:00:00 但并非总是如此，因为夏令时 ( DST） 或其他异常情况。顺便说一句，您可以通过调用 withTimeAtStartOfDay 对任何 DateTime 实例执行相同的操作。

格式化程序模式

格式化程序模式中使用的字符在 Joda-Time 中与 java.util.Date/Calendar 中的字符相似，但并不完全相同。仔细阅读文档。

不变性

我们通常在 Joda-Time 中使用不可变类。我们不是修改现有的日期时间对象，而是调用基于另一个对象创建新实例的方法，并复制大多数方面（除了需要更改的地方）。一个示例是下面最后一行中对 withZone 的调用。 不变性有助于让Joda-Time非常线程安全，也可以让一些工作更加清晰。

转换

您将需要 java.util.Date 对象来与不了解 Joda-Time 对象的其他类/框架一起使用。幸运的是，来回移动非常容易。

从 java.util.Date 对象（此处名为 date）到 Joda-Time DateTime...

org.joda.time.DateTime dateTime = new DateTime( date, timeZone );

从 Joda-Time 到 java.util.Date 对象的另一个方向...

java.util.Date date = dateTime.toDate();

示例代码

String input = "January 2, 2010";

java.util.Locale locale = java.util.Locale.US;
DateTimeZone timeZone = DateTimeZone.forID( "Pacific/Honolulu" ); // Arbitrarily chosen for example.
DateTimeFormatter formatter = DateTimeFormat.forPattern( "MMMM d, yyyy" ).withZone( timeZone ).withLocale( locale );
DateTime dateTime = formatter.parseDateTime( input );

System.out.println( "dateTime: " + dateTime );
System.out.println( "dateTime in UTC/GMT: " + dateTime.withZone( DateTimeZone.UTC ) );

运行时...

dateTime: 2010-01-02T00:00:00.000-10:00
dateTime in UTC/GMT: 2010-01-02T10:00:00.000Z

Answer 6

DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date;
try {
    date = dateFormat.parse("2013-12-4");
    System.out.println(date.toString()); // Wed Dec 04 00:00:00 CST 2013

    String output = dateFormat.format(date);
    System.out.println(output); // 2013-12-04
} 
catch (ParseException e) {
    e.printStackTrace();
}

它对我来说效果很好。

Answer 7

在处理 SimpleDateFormat 类时，请务必记住 Date 不是线程安全的，并且您不能与多个线程共享单个 Date 对象。

“m”和“M”之间也有很大的区别，小写表示分钟，大写表示月份。与“d”和“D”相同。这可能会导致经常被忽视的细微错误。请参阅 Javadoc 或 Java 中字符串转换为日期的指南 了解更多详细信息。

Answer 8

您可以使用 SimpleDateformat 将字符串更改为日期

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String strDate = "2000-01-01";
Date date = sdf.parse(strDate);

Answer 9

我们使用了两个简单的格式化程序：

1. 我们想要哪种格式的日期？
2. 实际存在哪种格式的日期？

我们解析完整的日期到时间格式：

date="2016-05-06 16:40:32";

public static String setDateParsing(String date) throws ParseException {

    // This is the format date we want
    DateFormat mSDF = new SimpleDateFormat("hh:mm a");

    // This format date is actually present
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-mm-dd hh:mm");
    return mSDF.format(formatter.parse(date));
}

Answer 10

此外，SimpleDateFormat 不适用于某些客户端技术，例如 GWT。

使用 Calendar.getInstance() 是个好主意，您的要求是比较两个日期；去长期约会。

Answer 11

我简陋的测试程序。我用它来使用格式化程序并查找我在日志文件中找到的长日期（但谁把它们放在那里......）。

我的测试程序：

package be.test.package.time;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;

public class TimeWork {

    public static void main(String[] args) {    

        TimeZone timezone = TimeZone.getTimeZone("UTC");

        List<Long> longs = new ArrayList<>();
        List<String> strings = new ArrayList<>();

        //Formatting a date needs a timezone - otherwise the date get formatted to your system time zone.
        //Use 24h format HH. In 12h format hh can be in range 0-11, which makes 12 overflow to 0.
        DateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss.SSS");
        formatter.setTimeZone(timezone);

        Date now = new Date();

        //Test dates
        strings.add(formatter.format(now));
        strings.add("01-01-1970 00:00:00.000");
        strings.add("01-01-1970 00:00:01.000");
        strings.add("01-01-1970 00:01:00.000");
        strings.add("01-01-1970 01:00:00.000");
        strings.add("01-01-1970 10:00:00.000");
        strings.add("01-01-1970 12:00:00.000");
        strings.add("01-01-1970 24:00:00.000");
        strings.add("02-01-1970 00:00:00.000");
        strings.add("01-01-1971 00:00:00.000");
        strings.add("01-01-2014 00:00:00.000");
        strings.add("31-12-1969 23:59:59.000");
        strings.add("31-12-1969 23:59:00.000");
        strings.add("31-12-1969 23:00:00.000");

        //Test data
        longs.add(now.getTime());
        longs.add(-1L);
        longs.add(0L); //Long date presentation at - midnight 1/1/1970 UTC - The timezone is important!
        longs.add(1L);
        longs.add(1000L);
        longs.add(60000L);
        longs.add(3600000L);
        longs.add(36000000L);
        longs.add(43200000L);
        longs.add(86400000L);
        longs.add(31536000000L);
        longs.add(1388534400000L);
        longs.add(7260000L);
        longs.add(1417706084037L);
        longs.add(-7260000L);

        System.out.println("===== String to long =====");

        //Show the long value of the date
        for (String string: strings) {
            try {
                Date date = formatter.parse(string);
                System.out.println("Formated date : " + string + " = Long = " + date.getTime());
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }

        System.out.println("===== Long to String =====");

        //Show the date behind the long
        for (Long lo : longs) {
            Date date = new Date(lo);
            String string = formatter.format(date);
            System.out.println("Formated date : " + string + " = Long = " + lo);        
        }
    }
}

测试结果：

===== String to long =====
Formated date : 05-12-2014 10:17:34.873 = Long = 1417774654873
Formated date : 01-01-1970 00:00:00.000 = Long = 0
Formated date : 01-01-1970 00:00:01.000 = Long = 1000
Formated date : 01-01-1970 00:01:00.000 = Long = 60000
Formated date : 01-01-1970 01:00:00.000 = Long = 3600000
Formated date : 01-01-1970 10:00:00.000 = Long = 36000000
Formated date : 01-01-1970 12:00:00.000 = Long = 43200000
Formated date : 01-01-1970 24:00:00.000 = Long = 86400000
Formated date : 02-01-1970 00:00:00.000 = Long = 86400000
Formated date : 01-01-1971 00:00:00.000 = Long = 31536000000
Formated date : 01-01-2014 00:00:00.000 = Long = 1388534400000
Formated date : 31-12-1969 23:59:59.000 = Long = -1000
Formated date : 31-12-1969 23:59:00.000 = Long = -60000
Formated date : 31-12-1969 23:00:00.000 = Long = -3600000
===== Long to String =====
Formated date : 05-12-2014 10:17:34.873 = Long = 1417774654873
Formated date : 31-12-1969 23:59:59.999 = Long = -1
Formated date : 01-01-1970 00:00:00.000 = Long = 0
Formated date : 01-01-1970 00:00:00.001 = Long = 1
Formated date : 01-01-1970 00:00:01.000 = Long = 1000
Formated date : 01-01-1970 00:01:00.000 = Long = 60000
Formated date : 01-01-1970 01:00:00.000 = Long = 3600000
Formated date : 01-01-1970 10:00:00.000 = Long = 36000000
Formated date : 01-01-1970 12:00:00.000 = Long = 43200000
Formated date : 02-01-1970 00:00:00.000 = Long = 86400000
Formated date : 01-01-1971 00:00:00.000 = Long = 31536000000
Formated date : 01-01-2014 00:00:00.000 = Long = 1388534400000
Formated date : 01-01-1970 02:01:00.000 = Long = 7260000
Formated date : 04-12-2014 15:14:44.037 = Long = 1417706084037
Formated date : 31-12-1969 21:59:00.000 = Long = -7260000

Answer 12

来源链接

对于 Android

Calendar.getInstance().getTime() 给出

Thu Jul 26 15:54:13 GMT+05:30 2018

使用

String oldDate = "Thu Jul 26 15:54:13 GMT+05:30 2018";
DateFormat format = new SimpleDateFormat("EEE LLL dd HH:mm:ss Z yyyy");
Date updateLast = format.parse(oldDate);

Answer 13

我致力于将 String 解析为 LocalDateTime。我把它留在这里作为例子

LocalDateTime d = LocalDateTime.parse("20180805 101010", DateTimeFormatter.ofPattern("yyyyMMdd HHmmss"));

我得到了

Answer 14

DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
  Date date1 = null;
  Date date2 = null;

  try {
    date1 = dateFormat.parse(t1);
    date2 = dateFormat.parse(t2);
  } catch (ParseException e) {
    e.printStackTrace();
  }
  DateFormat formatter = new SimpleDateFormat("dd-MMM-yyyy");
  String StDate = formatter.format(date1);
  String edDate = formatter.format(date2);

  System.out.println("ST  "+ StDate);
  System.out.println("ED "+ edDate);

Answer 15

From Date to String

SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
return sdf.format(date);

From String to Date

SimpleDateFormat sdf = new SimpleDateFormat(datePattern); 
return sdf.parse(dateStr);

From date String to different format

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat newSdf = new SimpleDateFormat("dd-MM-yyyy");
Date temp = sdf.parse(dateStr);
return newSdf.format(temp);

来源链接。

Answer 16

字符串到日期的转换：

private Date StringtoDate(String date) throws Exception {
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
            java.sql.Date sqlDate = null;
            if( !date.isEmpty()) {

                try {
                    java.util.Date normalDate = sdf1.parse(date);
                    sqlDate = new java.sql.Date(normalDate.getTime());
                } catch (ParseException e) {
                    throw new Exception("Not able to Parse the date", e);
                }
            }
            return sqlDate;
        }

Answer 17

试试这个

String date = get_pump_data.getString("bond_end_date");
DateFormat format = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
Date datee = (Date)format.parse(date);