변환하는 가장 좋은 방법은 무엇입니까 String'2010 년 1 월 2 일'형식의 DateJava를 Java ?

궁극적으로 월, 일 및 연도를 정수로 나누고 사용할 수 있습니다.

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

날짜를 시간으로 변환합니다.

그것은 어려운 방법이며, 이러한 java.util.Datesetter 메소드는 Java 1.1 (1997) 이후 더 이상 사용되지 않습니다. 입력 문자열과 일치하는 형식 패턴을 사용 SimpleDateFormat하여 날짜 형식을 지정하십시오. .

"2010 년 1 월 2 일"의 특정 경우 입력 문자열 :

1. "1 월"은 전체 텍스트 달이므로 MMMM패턴을 사용하십시오.
2. "2"는 짧은 기간이므로 d패턴을 사용하십시오.
3. "2010"은 4 자리 연도이므로 yyyy패턴을 사용하십시오.

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 의 관련성에 대한 추출입니다 .

Letter  Date or Time Component  Presentation        Examples
------  ----------------------  ------------------  -------------------------------------
G       Era designator          Text                AD
y       Year                    Year                1996; 96
Y       Week year               Year                2009; 09
M/L     Month in year           Month               July; Jul; 07
w       Week in year            Number              27
W       Week in month           Number              2
D       Day in year             Number              189
d       Day in month            Number              10
F       Day of week in month    Number              2
E       Day in week             Text                Tuesday; Tue
u       Day number of week      Number              1
a       Am/pm marker            Text                PM
H       Hour in day (0-23)      Number              0
k       Hour in day (1-24)      Number              24
K       Hour in am/pm (0-11)    Number              0
h       Hour in am/pm (1-12)    Number              12
m       Minute in hour          Number              30
s       Second in minute        Number              55
S       Millisecond             Number              978
z       Time zone               General time zone   Pacific Standard Time; PST; GMT-08:00
Z       Time zone               RFC 822 time zone   -0800
X       Time zone               ISO 8601 time zone  -08; -0800; -08:00

패턴은 대소 문자를 구분하며 4 자 이상의 텍스트 기반 패턴은 전체 형식을 나타냅니다. 그렇지 않으면 가능한 경우 짧거나 축약 된 형식이 사용됩니다. 따라서 예 MMMMM이상이 불필요합니다.

다음은 SimpleDateFormat주어진 문자열을 날짜별로 구문 분석하는 유효한 패턴의 예입니다 .

Input string                            Pattern
------------------------------------    ----------------------------
2001.07.04 AD at 12:08:56 PDT           yyyy.MM.dd G 'at' HH:mm:ss z
Wed, Jul 4, '01                         EEE, MMM d, ''yy
12:08 PM                                h:mm a
12 o'clock PM, Pacific Daylight Time    hh 'o''clock' a, zzzz
0:08 PM, PDT                            K:mm a, z
02001.July.04 AD 12:08 PM               yyyyy.MMMM.dd GGG hh:mm aaa
Wed, 4 Jul 2001 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이 아니라는 것 입니다. 즉, 정적 또는 인스턴스 변수로 선언하고 할당 한 다음 다른 메소드 / 스레드에서 재사용해서는 안됩니다. 항상 메소드 로컬 범위 내에서 새 것으로 작성해야합니다.

자바 8 업데이트

Java 8 이상을 사용하는 경우 다음을 사용하십시오 DateTimeFormatter(또한 여기에서 링크를 클릭하여 사전 정의 된 모든 포맷터 및 사용 가능한 형식 패턴을 확인 하십시오 (자습서는 여기에서 사용 가능함 )). 이 새로운 API는 JodaTime에서 영감을 받았습니다 .

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 의 관련성에 대한 추출입니다 .

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;

더 일반적인 패턴을 위해 미리 정의 된 포맷터 가 여러 개 있다는 점에 유의하십시오 . 예를 들어 대신을 DateTimeFormatter.ofPattern("EEE, d MMM yyyy HH:mm:ss Z", Locale.ENGLISH);사용할 수 있습니다 DateTimeFormatter.RFC_1123_DATE_TIME. 이는 SimpleDateFormat스레드 안전 과 달리 가능 합니다. 따라서 필요한 경우 자신을 정의 할 수도 있습니다.

특정 입력 문자열 형식의 경우 명시 적을 사용할 필요가 없습니다 DateTimeFormatter. 2016-09-26T17 : 44 : 57Z와 같은 표준 ISO 8601 날짜 LocalDateTime#parse(text)는 이미 ISO_LOCAL_DATE_TIME포맷터를 사용하므로 직접 구문 분석 할 수 있습니다 . 마찬가지로, LocalDate#parse(text)시간 구성 요소없이 ISO 날짜를 구문 분석하고 (참조 ISO_LOCAL_DATE) ZonedDateTime#parse(text)오프셋과 시간대를 추가하여 ISO 날짜를 구문 분석합니다 (참조 ISO_ZONED_DATE_TIME).

아, 다시 Java Date 토론입니다. 날짜 조작을 처리하기 위해 Date , Calendar , GregorianCalendar 및 SimpleDateFormat을 사용 합니다. 예를 들어 1 월 날짜를 입력으로 사용 :

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

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

Java 8에서는 새로운 날짜 / 시간 API ( JSR 310 )가 제공됩니다.

Joda-Time 에 의존하지 않고 Java 8에서 날짜를 구문 분석하는 데 다음 방법을 사용할 수 있습니다 .

 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 클래스입니다. 날짜 및 시간 정보가 포함 된 값을 구문 분석하려면 LocalDateTime 을 사용해야합니다 . 시간대가있는 값의 경우 ZonedDateTime을 사용 하십시오 . 둘 다 다음 parse()과 유사한 방법을 제공합니다 LocalDate.

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;

답변 중 일부는 기술적으로 정확하지만 권장되지 않습니다.

• java.util.Date & Calendar 클래스는 매우 귀찮습니다. 설계 및 구현상의 결함으로 인해이를 피하십시오. 다행히도 우리는 두 가지 다른 우수한 날짜-시간 라이브러리를 선택할 수 있습니다.
  • Joda-Time
    이 인기있는 오픈 소스 무료 라이브러리는 여러 Java 버전에서 사용할 수 있습니다. 사용법에 대한 많은 예는 StackOverflow에서 찾을 수 있습니다. 이 중 일부를 읽으면 빠르게 속도를 높일 수 있습니다.
  • java.time. * 패키지이
    새로운 클래스 세트는 Joda-Time에서 영감을 얻어 JSR 310에 의해 정의되었습니다.이 클래스는 Java 8에 내장되어 있습니다. 이러한 클래스를 Java 7로 백 포트하는 프로젝트가 진행 중이지만 백 포트는 지원되지 않습니다. 신탁.
• Kristopher Johnson이 질문에 대한 그의 의견에서 올바르게 언급했듯이 다른 답변은 다음과 같은 중요한 문제를 무시합니다.
  • 시간
    날짜에는 날짜 부분과 시간 부분이 모두 있습니다)
  • 시간대
    하루의 시작은 시간대에 따라 다릅니다. 시간대를 지정하지 않으면 JVM의 기본 시간대가 적용됩니다. 즉, 다른 컴퓨터에서 실행하거나 표준 시간대 설정을 수정하면 코드 동작이 변경 될 수 있습니다. 아마 당신이 원하는 것이 아닙니다.
  • 로케일
    로케일의 언어는 구문 분석 중에 발생하는 단어 (월 및 일 이름)를 해석하는 방법을 지정합니다. BalusC 의 답변 이이를 올바르게 처리합니다. 또한 로캘은 날짜-시간의 문자열 표현을 생성 할 때 일부 포맷터의 출력에 영향을줍니다.

조다 타임

Joda-Time에 대한 몇 가지 메모가 이어집니다.

시간대

에 Joda 타임 하는 날짜 시간 객체는 진정으로 자신의 할당 시간대를 알고있다. 이 java.util.Date 클래스 대조를 보인다 시간대를 가지고 있지만하지 않습니다.

아래 예제 코드에서 표준 시간대 객체를 문자열을 구문 분석하는 포맷터에 전달하는 방법에 유의하십시오. 해당 시간대는 해당 시간대에서 발생한 날짜-시간을 해석하는 데 사용됩니다. 따라서 해당 문자열 입력으로 표시되는 시간대를 생각하고 결정해야합니다.

입력 문자열에 시간 부분이 없으므로 Joda-Time은 지정된 시간대의 첫 번째 순간을 시간으로 지정합니다. 일반적으로 일광 절약 시간제 (DST) 또는 기타 이상으로 00:00:00인해 항상 그런 것은 아닙니다 . 그런데을 호출하여 모든 DateTime 인스턴스와 동일한 작업을 수행 할 수 있습니다 .withTimeAtStartOfDay

포맷터 패턴

포맷터의 패턴에 사용 된 문자는 Joda-Time에서 java.util.Date/Calendar의 문자와 유사하지만 정확히 동일하지는 않습니다. 문서를주의 깊게 읽으십시오.

불변성

우리는 일반적으로 Joda-Time에서 불변 클래스를 사용합니다. 기존 Date-Time 객체를 수정하는 대신 변경이 필요한 경우를 제외하고 대부분의 측면이 복사 된 다른 객체를 기반으로 새 인스턴스를 새로 만드는 메서드를 호출합니다. 예를 들어 withZone아래 마지막 줄에 전화하는 것이 있습니다. 불변성 은 Joda-Time을 스레드로부터 안전하게 만들고 일부 작업을 더 명확하게 만들 수 있습니다.

변환

Joda-Time 객체에 대해 모르는 다른 클래스 / 프레임 워크와 함께 사용하려면 java.util.Date 객체가 필요합니다. 다행히도 앞뒤로 이동하는 것이 매우 쉽습니다.

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

SimpleDateFormat 클래스를 처리하는 동안 Date는 스레드로부터 안전하지 않으며 단일 Date 객체를 여러 스레드와 공유 할 수 없다는 점을 기억해야합니다.

또한 작은 케이스는 몇 분, 대문자는 월은 "m"과 "M"사이에 큰 차이가 있습니다. "d"및 "D"와 동일합니다. 이로 인해 종종 간과되는 미묘한 버그가 발생할 수 있습니다. 자세한 내용은 Javadoc 또는 Java에서 문자열을 날짜로 변환하는 안내서를 참조하십시오.

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

그것은 나를 위해 잘 작동합니다.

문자열을 날짜로 변경하기 위해 SimpleDateformat을 사용할 수 있습니다

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

또한 GWT 와 같은 일부 클라이언트 측 기술에서는 SimpleDateFormat을 사용할 수 없습니다. .

Calendar.getInstance ()를 사용하는 것이 좋으며 두 날짜를 비교해야합니다. 데이트를 오래 가십시오.

우리가 사용한 간단한 두 가지 포맷터 :

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

나의 겸손한 시험 프로그램. 나는 그것을 사용하여 포맷터로 놀고 로그 파일에서 찾은 긴 날짜를 찾습니다 (그러나 누가 거기에 넣었는지 ...).

내 테스트 프로그램 :

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

소스 링크

대한 안드로이드

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

문자열을 날짜로 변환 :

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

이 시도

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