Qual è il modo migliore per convertire a Stringnel formato "2 gennaio 2010" in a Datein Java?

Alla fine, voglio suddividere il mese, il giorno e l'anno come numeri interi in modo da poterlo utilizzare

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

per convertire la data in ora.

È difficile, e quei java.util.Datemetodi setter sono stati deprecati da Java 1.1 (1997). Basta formattare la data utilizzando SimpleDateFormatun modello di formattazione corrispondente alla stringa di input .

Nel tuo caso specifico di "2 gennaio 2010" come stringa di input:

1. "Gennaio" è il mese di testo completo, quindi usa il MMMMmodello per questo
2. "2" è il breve giorno del mese, quindi usa lo dschema per questo.
3. "2010" è l'anno di 4 cifre, quindi usa il yyyymodello per questo.

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

Nota l'importanza Localedell'argomento esplicito . Se lo ometti, utilizzerà le impostazioni internazionali predefinite che non sono necessariamente inglesi, come quelle usate nel nome del mese della stringa di input. Se le impostazioni internazionali non corrispondono con la stringa di input, si otterrebbe confusamente java.text.ParseExceptionanche se il modello di formato sembra valido.

Ecco un estratto di rilevanza dal javadoc , che elenca tutti i modelli di formato disponibili:

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

Si noti che i motivi fanno distinzione tra maiuscole e minuscole e che motivi basati su testo di quattro caratteri o più rappresentano la forma completa; in caso contrario viene utilizzata una forma abbreviata o abbreviata, se disponibile. Quindi ad esempio MMMMMo più non è necessario.

Ecco alcuni esempi di SimpleDateFormatschemi validi per analizzare una data stringa fino ad oggi:

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

Una nota importante è che nonSimpleDateFormat è thread-safe. In altre parole, non dovresti mai dichiararlo e assegnarlo come variabile statica o di istanza e quindi riutilizzarlo da diversi metodi / thread. Dovresti sempre crearlo nuovo nell'ambito del metodo ambito locale.

Aggiornamento di Java 8

Se ti capita di trovarti su Java 8 o DateTimeFormatterversioni successive, utilizza (anche qui, fai clic sul collegamento per visualizzare tutti i formattatori predefiniti e i modelli di formato disponibili; il tutorial è disponibile qui ). Questa nuova API è ispirata a 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

Nota: se il modello di formato contiene anche la parte temporale, utilizzare LocalDateTime#parse(text, formatter)invece di LocalDate#parse(text, formatter). E, se il modello di formato contiene anche il fuso orario, utilizzare ZonedDateTime#parse(text, formatter)invece.

Ecco un estratto di rilevanza dal javadoc , che elenca tutti i modelli di formato disponibili:

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;

Si noti che ha diversi formattatori predefiniti per i modelli più popolari. Quindi, invece di ad esempio DateTimeFormatter.ofPattern("EEE, d MMM yyyy HH:mm:ss Z", Locale.ENGLISH);, potresti usare DateTimeFormatter.RFC_1123_DATE_TIME. Questo è possibile perché sono, al contrario SimpleDateFormat, thread-safe. Potresti quindi anche definire il tuo, se necessario.

Per un particolare formato di stringa di input, non è necessario utilizzare un esplicito DateTimeFormatter: una data ISO 8601 standard , come 2016-09-26T17: 44: 57Z, può essere analizzata direttamente LocalDateTime#parse(text)poiché utilizza già il ISO_LOCAL_DATE_TIMEformattatore. Allo stesso modo, LocalDate#parse(text)analizza una data ISO senza il componente orario (vedi ISO_LOCAL_DATE) e ZonedDateTime#parse(text)analizza una data ISO con un offset e un fuso orario aggiunti (vedi ISO_ZONED_DATE_TIME).

Ah sì, di nuovo la discussione su Java Date. Per gestire la manipolazione della data utilizziamo Date , Calendar , GregorianCalendar e SimpleDateFormat . Ad esempio, utilizzando la data di gennaio come input:

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

Quindi puoi manipolarlo con qualcosa del tipo:

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

Con Java 8 otteniamo una nuova API Date / Time ( JSR 310 ).

Il seguente modo può essere utilizzato per analizzare la data in Java 8 senza fare affidamento su 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 è la classe Java 8 standard per rappresentare una data (senza ora). Se si desidera analizzare valori che contengono informazioni su data e ora, è necessario utilizzare LocalDateTime . Per i valori con fusi orari utilizzare ZonedDateTime . Entrambi forniscono un parse()metodo simile a LocalDate:

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

L'elenco dei caratteri di formattazione da 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;

Sebbene alcune delle risposte siano tecnicamente corrette, non sono consigliabili.

• Le classi java.util.Date & Calendar sono notoriamente problematiche. A causa di difetti di progettazione e realizzazione, evitarli. Fortunatamente abbiamo la nostra scelta di altre due eccellenti librerie di data e ora:
  • Joda-Time
    Questa popolare libreria open source gratuita può essere utilizzata in diverse versioni di Java. Molti esempi del suo utilizzo possono essere trovati su StackOverflow. La lettura di alcuni di questi ti aiuterà ad accelerare rapidamente.
  • pacchetto java.time. *
    Questo nuovo set di classi è ispirato a Joda-Time e definito da JSR 310. Queste classi sono integrate in Java 8. È in corso un progetto per il backport di queste classi su Java 7, ma il backport non è supportato da Oracolo.
• Come Kristopher Johnson ha correttamente osservato nel suo commento sulla domanda, le altre risposte ignorano le questioni vitali di:
  • Ora del giorno La
    data ha sia una parte della data che una parte dell'ora del giorno)
  • Fuso orario
    L'inizio di un giorno dipende dal fuso orario. Se non si specifica un fuso orario, viene applicato il fuso orario predefinito della JVM. Ciò significa che il comportamento del codice può cambiare quando eseguito su altri computer o con un'impostazione del fuso orario modificata. Probabilmente non quello che vuoi.
  • Impostazioni
    internazionali La lingua delle impostazioni internazionali specifica come interpretare le parole (nome del mese e del giorno) incontrate durante l'analisi. (La risposta di BalusC lo gestisce correttamente.) Inoltre, le impostazioni locali influiscono sull'output di alcuni formattatori quando si genera una rappresentazione in formato stringa della data e dell'ora.

Joda-Time

Seguono alcune note su Joda-Time.

Fuso orario

In Joda-Time , un oggetto DateTime conosce veramente il proprio fuso orario assegnato. Ciò contrasta con la classe java.util.Date che sembra avere un fuso orario ma non lo è.

Nota nel seguente codice di esempio come passiamo un oggetto fuso orario al formatter che analizza la stringa. Quel fuso orario viene utilizzato per interpretare quella data-ora come avvenuta in quel fuso orario. Quindi è necessario pensare e determinare il fuso orario rappresentato dall'input di quella stringa.

Poiché non è presente alcuna porzione di tempo nella stringa di input, Joda-Time assegna il primo momento del giorno del fuso orario specificato come ora del giorno. Di solito questo significa, 00:00:00ma non sempre, a causa dell'ora legale (DST) o di altre anomalie. A proposito, puoi fare lo stesso con qualsiasi istanza di DateTime chiamandowithTimeAtStartOfDay .

Modello di formattatore

I personaggi usati nel modello di un formattatore sono simili in Joda-Time a quelli in java.util.Date/Calendar ma non esattamente gli stessi. Leggi attentamente il documento.

Immutabilità

Di solito usiamo le classi immutabili in Joda-Time. Piuttosto che modificare un oggetto Date-Time esistente, chiamiamo metodi che creano una nuova istanza nuova basata sull'altro oggetto con la maggior parte degli aspetti copiati, tranne nei casi in cui si desiderassero alterazioni. Un esempio è la chiamata withZoneall'ultima riga in basso. L'immutabilità aiuta a rendere Joda-Time molto sicuro per i thread e può anche rendere più chiaro il lavoro.

Conversione

Avrai bisogno degli oggetti java.util.Date per l'uso con altre classi / framework che non conoscono gli oggetti Joda-Time. Fortunatamente, è molto facile spostarsi avanti e indietro.

Passando da un oggetto java.util.Date (qui chiamato date) a Joda-Time DateTime ...

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

Andando nella direzione opposta da Joda-Time a un oggetto java.util.Date ...

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

Codice di esempio

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

Quando eseguito ...

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

Mentre si ha a che fare con la classe SimpleDateFormat, è importante ricordare che Date non è thread-safe e non è possibile condividere un singolo oggetto Date con più thread.

Inoltre c'è una grande differenza tra "m" e "M" in cui viene utilizzata la minuscola per i minuti e la maiuscola per il mese. Lo stesso con "d" e "D". Ciò può causare bug sottili che spesso vengono trascurati. Consulta Javadoc o la Guida per convertire la stringa in data in Java per maggiori dettagli.

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

Funziona bene per me.

È possibile utilizzare SimpleDateformat per modificare la stringa fino ad oggi

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

Inoltre, SimpleDateFormat non è disponibile con alcune delle tecnologie lato client, come GWT .

È una buona idea optare per Calendar.getInstance () e il tuo requisito è confrontare due date; andare per un lungo appuntamento.

Abbiamo usato due semplici formatter:

1. Quale data del formato vogliamo?
2. Quale data del formato è attualmente presente?

Analizziamo il formato completo dalla data all'ora:

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

Il mio umile programma di test. Lo uso per giocare con il formattatore e cercare lunghe date che trovo nei file di registro (ma chi li ha messi lì ...).

Il mio programma di test:

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

Risultati del test:

===== 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

Link alla fonte

Per Android

Calendar.getInstance (). GetTime () dà

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

Uso

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

Conversione da stringa a data:

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

Prova questo

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