Quelle est la meilleure façon de convertir un Stringau format «2 janvier 2010» en un Dateen Java?

En fin de compte, je veux décomposer le mois, le jour et l'année sous forme d'entiers afin de pouvoir utiliser

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

pour convertir la date en heure.

C'est la voie difficile, et ces java.util.Dateméthodes de définition sont obsolètes depuis Java 1.1 (1997). Formatez simplement la date en SimpleDateFormatutilisant un modèle de format correspondant à la chaîne d'entrée .

Dans votre cas spécifique de "2 janvier 2010" comme chaîne d'entrée:

1. "Janvier" est le mois du texte intégral, utilisez donc le MMMMmodèle pour cela
2. "2" est le court jour du mois, utilisez donc le dmodèle pour cela.
3. "2010" est l'année à 4 chiffres, utilisez donc le yyyymodèle pour cela.

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

Notez l'importance de l' Localeargument explicite . Si vous l'omettez, il utilisera les paramètres régionaux par défaut qui ne sont pas nécessairement l'anglais comme utilisé dans le nom du mois de la chaîne d'entrée. Si les paramètres régionaux ne correspondent pas à la chaîne d'entrée, vous obtiendrez alors une confusion, java.text.ParseExceptionmême si le modèle de format semble valide.

Voici un extrait de la pertinence du javadoc , répertoriant tous les modèles de format disponibles:

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

Notez que les modèles sont sensibles à la casse et que les modèles basés sur du texte de quatre caractères ou plus représentent la forme complète; sinon, un formulaire court ou abrégé est utilisé s'il est disponible. Donc, par exemple, MMMMMou plus n'est pas nécessaire.

Voici quelques exemples de SimpleDateFormatmodèles valides pour analyser une chaîne donnée à ce jour:

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

Une note importante est que ce SimpleDateFormatn'est pas sûr pour les threads. En d'autres termes, vous ne devez jamais le déclarer et l'assigner en tant que variable statique ou d'instance, puis le réutiliser à partir de différentes méthodes / threads. Vous devez toujours le créer tout nouveau dans le cadre local de la méthode.

Mise à jour Java 8

Si vous êtes sur Java 8 ou une version plus récente, utilisez DateTimeFormatter(également ici, cliquez sur le lien pour voir tous les formateurs prédéfinis et les modèles de format disponibles; le tutoriel est disponible ici ). Cette nouvelle API est inspirée de 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

Remarque: si votre modèle de format contient également la partie temps, utilisez-le à la LocalDateTime#parse(text, formatter)place de LocalDate#parse(text, formatter). Et, si votre modèle de format contient également le fuseau horaire, utilisez-le à la ZonedDateTime#parse(text, formatter)place.

Voici un extrait de la pertinence du javadoc , répertoriant tous les modèles de format disponibles:

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;

Notez qu'il a plusieurs formateurs prédéfinis pour les modèles les plus populaires. Donc, au lieu de, par exemple DateTimeFormatter.ofPattern("EEE, d MMM yyyy HH:mm:ss Z", Locale.ENGLISH);, vous pouvez utiliser DateTimeFormatter.RFC_1123_DATE_TIME. Cela est possible car ils sont, au contraire SimpleDateFormat, thread-safe. Vous pouvez donc également définir le vôtre, si nécessaire.

Pour un format de chaîne d'entrée particulier, vous n'avez pas besoin d'utiliser une explicite DateTimeFormatter: une date ISO 8601 standard , comme 2016-09-26T17: 44: 57Z, peut être analysée directement LocalDateTime#parse(text)car elle utilise déjà le ISO_LOCAL_DATE_TIMEformateur. De même, LocalDate#parse(text)analyse une date ISO sans le composant temps (voir ISO_LOCAL_DATE) et ZonedDateTime#parse(text)analyse une date ISO avec un décalage et un fuseau horaire ajoutés (voir ISO_ZONED_DATE_TIME).

Ah oui, la discussion Java Date, encore une fois. Pour gérer la manipulation des dates , nous utilisons Date , Calendar , GregorianCalendar et SimpleDateFormat . Par exemple, en utilisant votre date de janvier comme entrée:

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

Ensuite, vous pouvez manipuler cela avec quelque chose comme:

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

Avec Java 8, nous obtenons une nouvelle API de date / heure ( JSR 310 ).

La méthode suivante peut être utilisée pour analyser la date dans Java 8 sans compter sur 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 est la classe Java 8 standard pour représenter une date (sans heure). Si vous souhaitez analyser des valeurs contenant des informations de date et d'heure, vous devez utiliser LocalDateTime . Pour les valeurs avec des fuseaux horaires, utilisez ZonedDateTime . Les deux fournissent une parse()méthode similaire à LocalDate:

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

La liste des caractères de mise en forme de 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;

Bien que certaines des réponses soient techniquement correctes, elles ne sont pas recommandées.

• Les classes java.util.Date & Calendar sont notoirement gênantes. En raison de défauts de conception et de mise en œuvre, évitez-les. Heureusement, nous avons le choix entre deux autres excellentes bibliothèques date-heure:
  • Joda-Time
    Cette bibliothèque gratuite open-source populaire peut être utilisée sur plusieurs versions de Java. De nombreux exemples de son utilisation peuvent être trouvés sur StackOverflow. La lecture de certains de ces documents vous aidera à vous mettre rapidement au courant.
  • java.time. * package
    Ce nouvel ensemble de classes est inspiré de Joda-Time et défini par JSR 310. Ces classes sont intégrées à Java 8. Un projet est en cours pour rétroporter ces classes vers Java 7, mais ce rétroportage n'est pas soutenu par Oracle.
• Comme Kristopher Johnson l'a correctement noté dans son commentaire sur la question, les autres réponses ignorent les questions essentielles de:
  • La date de l'heure
    comprend une partie date et une partie heure)
  • Fuseau horaire
    Le début d'une journée dépend du fuseau horaire. Si vous ne spécifiez pas de fuseau horaire, le fuseau horaire par défaut de la JVM est appliqué. Cela signifie que le comportement de votre code peut changer lorsqu'il est exécuté sur d'autres ordinateurs ou avec un paramètre de fuseau horaire modifié. Probablement pas ce que vous voulez.
  • Paramètres
    régionaux Le langage des paramètres régionaux spécifie comment interpréter les mots (nom du mois et du jour) rencontrés lors de l'analyse. (La réponse de BalusC gère cela correctement.) De plus, les paramètres régionaux affectent la sortie de certains formateurs lors de la génération d'une représentation sous forme de chaîne de votre date-heure.

Joda-Time

Voici quelques notes sur Joda-Time.

Fuseau horaire

Dans Joda-Time , un objet DateTime connaît vraiment son propre fuseau horaire attribué. Cela contraste avec la classe java.util.Date qui semble avoir un fuseau horaire mais pas.

Notez dans l'exemple de code ci-dessous comment nous passons un objet de fuseau horaire au formateur qui analyse la chaîne. Ce fuseau horaire est utilisé pour interpréter cette date-heure comme s'étant produite dans ce fuseau horaire. Vous devez donc penser et déterminer le fuseau horaire représenté par cette entrée de chaîne.

Comme vous n'avez pas de partie d'heure dans votre chaîne d'entrée, Joda-Time affecte le premier moment du jour du fuseau horaire spécifié comme heure du jour. Habituellement, cela signifie 00:00:00mais pas toujours, en raison de l' heure d'été (DST) ou d'autres anomalies. Soit dit en passant, vous pouvez faire de même pour n'importe quelle instance DateTime en appelant withTimeAtStartOfDay.

Modèle de formateur

Les caractères utilisés dans le modèle d'un formateur sont similaires dans Joda-Time à ceux de java.util.Date/Calendar mais pas exactement les mêmes. Lisez attentivement le doc.

Immutabilité

Nous utilisons généralement les classes immuables dans Joda-Time. Plutôt que de modifier un objet Date-Heure existant, nous appelons des méthodes qui créent une nouvelle instance basée sur l'autre objet avec la plupart des aspects copiés sauf là où des modifications étaient souhaitées. Un exemple est l'appel à la withZonedernière ligne ci-dessous. L'immutabilité aide à rendre Joda-Time très sûr pour les threads, et peut également rendre certains travaux plus clairs.

Conversion

Vous aurez besoin d'objets java.util.Date à utiliser avec d'autres classes / frameworks qui ne connaissent pas les objets Joda-Time. Heureusement, il est très facile de se déplacer d'avant en arrière.

Passer d'un objet java.util.Date (ici nommé date) à Joda-Time DateTime…

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

Aller dans l'autre sens de Joda-Time vers un objet java.util.Date…

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

Exemple de code

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

Lors de l'exécution ...

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

Lors de l'utilisation de la classe SimpleDateFormat, il est important de se rappeler que Date n'est pas adapté aux threads et que vous ne pouvez pas partager un seul objet Date avec plusieurs threads.

Il y a aussi une grande différence entre "m" et "M" où la petite caisse est utilisée pour les minutes et la majuscule pour le mois. La même chose avec "d" et "D". Cela peut provoquer des bugs subtils qui sont souvent négligés. Voir Javadoc ou Guide de conversion de chaîne en date en Java pour plus de détails.

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

Ça fonctionne bien pour moi.

Vous pouvez utiliser SimpleDateformat pour modifier la chaîne à ce jour

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

De plus, SimpleDateFormat n'est pas disponible avec certaines des technologies côté client, comme GWT .

C'est une bonne idée d'opter pour Calendar.getInstance (), et votre exigence est de comparer deux dates; allez pour longue date.

Deux formateurs simples que nous avons utilisés:

1. Quel format de date voulons-nous?
2. Quel format de date est réellement présent?

Nous analysons le format complet de la date à l'heure:

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

Mon humble programme de test. Je l'utilise pour jouer avec le formateur et rechercher les longues dates que je trouve dans les fichiers journaux (mais qui les a mis là ...).

Mon programme de 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);        
        }
    }
}

Résultats de 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

Lien source

Pour Android

Calendar.getInstance (). GetTime () donne

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

Utilisation

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

Conversion de chaîne en date:

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

Essaye ça

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