Qual é a melhor maneira de converter um Stringno formato '2 de janeiro de 2010' em um Dateem Java?

Por fim, quero dividir o mês, o dia e o ano como números inteiros para que eu possa usar

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

para converter a data em hora.

Essa é a maneira mais difícil, e esses java.util.Datemétodos setter estão obsoletos desde o Java 1.1 (1997). Simplesmente formate a data usando SimpleDateFormatum padrão de formato correspondente à sequência de entrada .

No seu caso específico de "2 de janeiro de 2010" como a sequência de entrada:

1. "Janeiro" é o mês do texto completo, portanto, use o MMMMpadrão para ele
2. "2" é o dia do mês curto, então use o dpadrão para ele.
3. "2010" é o ano de quatro dígitos, portanto, use o yyyypadrão para ele.

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

Observe a importância do Localeargumento explícito . Se você o omitir, ele usará o código do idioma padrão, que não é necessariamente inglês, como é usado no nome do mês da sequência de entrada. Se o código do idioma não corresponder à sequência de entrada, você poderá obter um resultado confuso java.text.ParseExceptionquando o padrão de formato parecer válido.

Aqui está um extrato de relevância do javadoc , listando todos os padrões de formato disponíveis:

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

Observe que os padrões diferenciam maiúsculas de minúsculas e que os padrões baseados em texto de quatro caracteres ou mais representam a forma completa; caso contrário, um formulário curto ou abreviado é usado, se disponível. Então, por exemplo, MMMMMou mais, é desnecessário.

Aqui estão alguns exemplos de SimpleDateFormatpadrões válidos para analisar uma determinada string até o momento:

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

Uma observação importante é que nãoSimpleDateFormat é seguro para threads. Em outras palavras, você nunca deve declarar e atribuí-lo como uma variável estática ou de instância e, em seguida, reutilizá-lo de diferentes métodos / threads. Você sempre deve criá-lo totalmente novo no escopo local do método.

Atualização do Java 8

Se você estiver no Java 8 ou mais recente, use DateTimeFormatter(também aqui, clique no link para ver todos os formatadores predefinidos e padrões de formatos disponíveis; o tutorial está disponível aqui ). Essa nova API é inspirada no 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 o seu padrão de formato também contiver a parte da hora, use em LocalDateTime#parse(text, formatter)vez de LocalDate#parse(text, formatter). E, se o seu padrão de formato também contiver o fuso horário, use-o ZonedDateTime#parse(text, formatter).

Aqui está um extrato de relevância do javadoc , listando todos os padrões de formato disponíveis:

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;

Observe que ele possui vários formatadores predefinidos para os padrões mais populares. Então, em vez de DateTimeFormatter.ofPattern("EEE, d MMM yyyy HH:mm:ss Z", Locale.ENGLISH);, por exemplo , você poderia usar DateTimeFormatter.RFC_1123_DATE_TIME. Isso é possível porque eles são, ao contrário SimpleDateFormat, seguros para threads. Assim, você também pode definir o seu, se necessário.

Para um formato de sequência de entrada específico, não é necessário usar um explícito DateTimeFormatter: uma data ISO 8601 padrão , como 2016-09-26T17: 44: 57Z, pode ser analisada diretamente LocalDateTime#parse(text), pois já usa o ISO_LOCAL_DATE_TIMEformatador. Da mesma forma, LocalDate#parse(text)analisa uma data ISO sem o componente de hora (consulte a ISO_LOCAL_DATE) e ZonedDateTime#parse(text)analisa uma data ISO com um deslocamento e o fuso horário adicionados (consulte ISO_ZONED_DATE_TIME).

Ah, sim a discussão sobre o Java Date, novamente. Para lidar com a manipulação de datas, usamos Date , Calendar , GregorianCalendar e SimpleDateFormat . Por exemplo, usando sua data de janeiro como entrada:

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

Então você pode manipular isso com algo como:

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

Com o Java 8, obtemos uma nova API de Data / Hora ( JSR 310 ).

A maneira a seguir pode ser usada para analisar a data no Java 8 sem depender do 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 é a classe Java 8 padrão para representar uma data (sem hora). Se você deseja analisar valores que contêm informações de data e hora, use LocalDateTime . Para valores com fusos horários, use ZonedDateTime . Ambos fornecem um parse()método semelhante a LocalDate:

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

Os caracteres de formatação da lista do Javadoc DateTimeFormatter :

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;

Embora algumas das respostas sejam tecnicamente corretas, elas não são aconselháveis.

• As classes java.util.Date e Calendar são notoriamente problemáticas. Devido a falhas no projeto e na implementação, evite-as. Felizmente, podemos escolher entre duas outras excelentes bibliotecas de data e hora:
  • Joda-Time
    Esta popular biblioteca gratuita de código aberto pode ser usada em várias versões do Java. Muitos exemplos de seu uso podem ser encontrados no StackOverflow. A leitura de alguns deles ajudará você a se familiarizar rapidamente.
  • pacote java.time. *
    Este novo conjunto de classes é inspirado no Joda-Time e definido pelo JSR 310. Essas classes estão integradas no Java 8. Está em andamento um projeto para suportar essas classes no Java 7, mas esse backport não é suportado por Oráculo.
• Como Kristopher Johnson observou corretamente em seu comentário sobre a pergunta, as outras respostas ignoram questões vitais de:
  • 
    Data do dia tem uma parte da data e uma parte da hora do dia)
  • Fuso horário
    O início de um dia depende do fuso horário. Se você não especificar um fuso horário, o fuso horário padrão da JVM será aplicado. Isso significa que o comportamento do seu código pode mudar quando executado em outros computadores ou com uma configuração de fuso horário modificada. Provavelmente não é o que você quer.
  • Localidade
    O idioma da localidade especifica como interpretar as palavras (nome do mês e do dia) encontradas durante a análise. (A resposta de BalusC lida com isso adequadamente.) Além disso, o código de idioma afeta a saída de alguns formatadores ao gerar uma representação de seqüência de caracteres de sua data e hora.

Joda-Time

Seguem algumas notas sobre o Joda-Time.

Fuso horário

No Joda-Time , um objeto DateTime realmente conhece seu próprio fuso horário atribuído. Isso contrasta a classe java.util.Date, que parece ter um fuso horário, mas não.

Observe no código de exemplo abaixo como passamos um objeto de fuso horário para o formatador que analisa a string. Esse fuso horário é usado para interpretar a data e hora como ocorridas nesse fuso horário. Então, você precisa pensar e determinar o fuso horário representado por essa entrada de sequência.

Como você não possui uma parte da hora na sequência de entrada, o Joda-Time atribui o primeiro momento do dia do fuso horário especificado como a hora do dia. Geralmente isso significa, 00:00:00mas nem sempre, por causa do horário de verão (DST) ou outras anomalias. A propósito, você pode fazer o mesmo com qualquer instância DateTime chamando withTimeAtStartOfDay.

Padrão do formatador

Os caracteres usados ​​no padrão de um formatador são semelhantes no Joda-Time aos caracteres no java.util.Date/Calendar, mas não exatamente iguais. Leia atentamente o documento.

Imutabilidade

Geralmente usamos as classes imutáveis ​​no Joda-Time. Em vez de modificar um objeto Date-Time existente, chamamos métodos que criam uma nova instância nova com base no outro objeto com a maioria dos aspectos copiados, exceto onde as alterações foram desejadas. Um exemplo é a chamada para withZonena última linha abaixo. A imutabilidade ajuda a tornar o Joda-Time muito seguro para threads e também pode tornar o trabalho mais claro.

Conversão

Você precisará de objetos java.util.Date para uso com outras classes / estruturas que não conhecem os objetos Joda-Time. Felizmente, é muito fácil ir e voltar.

Indo de um objeto java.util.Date (aqui chamado date) para Joda-Time DateTime…

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

Indo na outra direção de Joda-Time para um objeto java.util.Date…

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

Código de amostra

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 correr ...

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

Ao lidar com a classe SimpleDateFormat, é importante lembrar que o Date não é seguro para threads e você não pode compartilhar um único objeto Date com vários threads.

Também há uma grande diferença entre "m" e "M", onde letras minúsculas são usadas por minutos e letras maiúsculas são usadas por mês. O mesmo com "d" e "D". Isso pode causar erros sutis que geralmente são esquecidos. Consulte Javadoc ou Guide to Convert String to Date em Java para obter mais detalhes.

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

Isso funciona bem para mim.

Você pode usar o SimpleDateformat para alterar a string até a data

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

Além disso, SimpleDateFormat não está disponível com algumas das tecnologias do lado do cliente, como GWT .

É uma boa ideia ir para Calendar.getInstance (), e sua exigência é comparar duas datas; vá para um encontro longo.

Dois formatadores simples que usamos:

1. Que formato de data queremos?
2. Qual data do formato está realmente presente?

Analisamos o formato completo de data e hora:

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

Meu humilde programa de teste. Eu o uso para brincar com o formatador e procurar longas datas que encontro nos arquivos de log (mas quem os colocou lá ...).

Meu programa de teste:

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

Resultado dos testes:

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

Para Android

Calendar.getInstance (). GetTime () fornece

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

Usar

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

Conversão de String para 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;
        }

Tente isto

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