Antwoord 2, autoriteit 4%

Ah ja, de Java Date-discussie, alweer. Om met datummanipulatie om te gaan, gebruiken we Datum, Agenda, GregorianCalendaren SimpleDateFormat. Gebruik bijvoorbeeld uw januari-datum als invoer:

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

Dan kun je dat manipuleren met zoiets als:

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

3, Autoriteit 3%

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

4, Autoriteit 3%

Met Java 8 krijgen we een nieuwe datum / tijd API (JSR 310 ).

De volgende manier kan worden gebruikt om de datum in Java 8 te ontleden zonder te vertrouwen op 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

LocalDateis de standaard Java 8 klasse voor het vertegenwoordigen van een datum (zonder tijd). Als u waarden wilt ontleden die datum- en tijdinformatie bevatten, moet u LocalDateTime. Gebruik voor waarden met tijdzones ZonedDateTime. Beide bieden een parse()-methode vergelijkbaar met LocalDate:

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

De lijstopmaaktekens van 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;

Antwoord 5, autoriteit 2%

Hoewel sommige antwoorden technisch correct zijn, zijn ze niet aan te raden.

• De java.util.Date & Kalenderklassen zijn notoir lastig. Vermijd ze vanwege gebreken in ontwerp en implementatie. Gelukkig hebben we de keuze uit twee andere uitstekende datum-tijdbibliotheken:
  • joda-time
    deze populaire open- Source Free-Cost-bibliotheek kan in verschillende versies van Java worden gebruikt. Veel voorbeelden van het gebruik zijn te vinden op een stapelaars. Het lezen van sommige hiervan helpt je snel op de hoogte te stellen.
  • java.time. * Pakket
    Deze nieuwe set klassen zijn geïnspireerd op Joda-Time en gedefinieerd door JSR 310. Deze klassen zijn ingebouwd in Java 8. Er is een project aan de gang om deze klassen naar Java 7 te maken, maar dat backporting wordt niet ondersteund door Oracle.
• Zoals Kristopher Johnson correct opmerkte in zijn opmerking over de vraag, negeren de andere antwoorden vitale kwesties van:
  • Tijd van de dag
    Datum heeft zowel een datumgedeelte als een tijdsgedeelte)
  • tijdzone
    Het begin van een dag is afhankelijk van de tijdzone. Als u geen tijdzone opgeven, wordt de standaardtijdzone van de JVM toegepast. Dat betekent dat het gedrag van uw code kan veranderen bij het uitvoeren van andere computers of met een gewijzigde tijdzone-instelling. Waarschijnlijk niet wat je wilt.
  • Locale
    De taal van de locale specificeert hoe de woorden (naam van de maand en van de dag) tijdens het parseren tegenkomen te interpreteren. (The Antwoord door BALUSC verwerkt dit op de juiste manier.) Ook beïnvloedt de locale de uitvoer van sommige formatters bij het genereren van een reeksvertegenwoordiging van uw datum-tijd.

JODA-TIME

enkele opmerkingen over Joda-Time Follow.

Tijdzone

In Joda-Time, een DateTime-object kent echt zijn eigen toegewezen tijdzone. Dit in tegenstelling tot de klasse java.util.Date die lijkteen tijdzone te hebben, maar deze niet heeft.

Let in de voorbeeldcode hieronder hoe we een tijdzone-object doorgeven aan de formatter die de string parseert. Die tijdzone wordt gebruikt om die datum-tijd te interpreteren alsof deze zich in die tijdzone heeft voorgedaan. U moet dus nadenken over de tijdzone die wordt vertegenwoordigd door die tekenreeksinvoer en deze bepalen.

Omdat u geen tijdsgedeelte in uw invoerreeks heeft, wijst Joda-Time het eerste moment van de dag van de opgegeven tijdzone toe als de tijd van de dag. Meestal betekent dit 00:00:00maar niet altijd, vanwege Zomertijd ( zomertijd)of andere afwijkingen. Trouwens, je kunt hetzelfde doen met elke DateTime-instantie door withTimeAtStartOfDayaan te roepen.

Opmaakpatroon

De tekens die in het patroon van een formatter worden gebruikt, lijken in Joda-Time op die in java.util.Date/Calendar, maar zijn niet precies hetzelfde. Lees het document aandachtig.

Onveranderlijkheid

We gebruiken meestal de onveranderlijke klassen in Joda-Time. In plaats van een bestaand Date-Time-object te wijzigen, roepen we methoden aan die een nieuwe verse instantie creëren op basis van het andere object met de meeste aspecten gekopieerd, behalve waar wijzigingen gewenst waren. Een voorbeeld is de aanroep naar withZonein de laatste regel hieronder. Onveranderlijkheidhelpt om Joda-Time zeer thread-safe te maken, en kan sommige werkzaamheden ook duidelijker maken.

Conversie

Je hebt java.util.Date-objecten nodig voor gebruik met andere klassen/frameworks die geen kennis hebben van Joda-Time-objecten. Gelukkig is het heel gemakkelijk om heen en weer te gaan.

Van een java.util.Date-object (hier dategenoemd) naar Joda-Time DateTime…

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

De andere kant op gaan van Joda-Time naar een java.util.Date object…

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

Voorbeeldcode

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

Wanneer uitgevoerd…

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

Antwoord 6

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

Het werkt prima voor mij.

Antwoord 7

Tijdens het omgaan met de SimpledateFormat-klasse is het belangrijk om te onthouden dat datum niet draadveilig is en u kunt geen object met een enkele datum met meerdere draden delen.

Er is ook een groot verschil tussen “m” en “m” waar kleine zaak gedurende minuten wordt gebruikt en de kapitaalgeval wordt voor maand gebruikt. Hetzelfde met “D” en “D”. Dit kan subtiele bugs veroorzaken die vaak over het hoofd worden gezien. Zie Javadoc of gids om string tot nu toe te converteren in Java voor meer details.

8

Eenvoudige twee formatterers die we hebben gebruikt:

1. Welke formaatdatum willen we?
2. Welke formaatdatum is eigenlijk aanwezig?

We parseren de volledige datum tot tijdsindeling:

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

9

U kunt SimpledateFormat gebruiken voor wijzigingsstring tot nu toe

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

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

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

DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
  Date date1 = null;
  Date date2 = null;
  try {
    date1 = dateFormat.parse(t1);
    date2 = dateFormat.parse(t2);
  } catch (ParseException e) {
    e.printStackTrace();
  }
  DateFormat formatter = new SimpleDateFormat("dd-MMM-yyyy");
  String StDate = formatter.format(date1);
  String edDate = formatter.format(date2);
  System.out.println("ST  "+ StDate);
  System.out.println("ED "+ edDate);

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

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

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

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