Java Dato og klokkeslett

Håndtering av datoer og klokkeslett i Java er en rutinemessig del av å bygge planleggingslogikk, logge tidsstempler, rapporter og revisjonsspor. Før du skriver kode, er det nyttig å kjenne parameterne som utgjør en dato:

• Ocuco år (med to eller fire sifre).
• Ocuco måned (som to sifre, som de tre første bokstavene i måneden, eller som hele månedsnavnet).
• Ocuco data (det faktiske tallet for månedsdag).
• Ocuco dag (dagens navn på den gitte datoen, for eksempel søn, man, tir).

Java eksponerer mange andre parametere som beskriver et øyeblikk på tidslinjen, inkludert æra, uke i året, tidssone og forskyvning. Avsnittene nedenfor dekker hver av dem med kjørbare eksempler.

Vis dato i Java

Java gir en Date klasse i java.util pakke. Klassen lagrer et spesifikt øyeblikk med millisekundpresisjon og tilbyr hjelpemetoder for å skrive ut, sammenligne og formatere det øyeblikket. For å få gjeldende dato og klokkeslett, instansier klassen med standardkonstruktøren:

import java.util.Date;

class Date_Ex1 {
    public static void main(String args[]) {
        // Instantiate a Date object by invoking its constructor
        Date objDate = new Date();
        // Display the Date and Time using toString()
        System.out.println(objDate.toString());
    }
}

Utgang:

Wed Nov 29 06:36:22 UTC 2017

Eksemplet skriver ut datoen i standard toString-formatet. For å vise samme øyeblikk i et annet mønster, må du først forstå formateringsbokstavene som Java bruker.

SimpleDateFormat: Parse og formater datoer

Ocuco SimpleDateFormat klasse i java.text konverterer en Date objektet til en formatert streng og analyserer en formatert streng tilbake til en DateDen bruker mønsterbokstaver som tilordnes en dato- eller klokkeslettkomponent. Tabellen nedenfor viser alle støttede bokstaver:

Du trenger ikke å huske hele tabellen. Bruk den hver gang du lager et nytt mønster.

Slik bruker du SimpleDateFormat

SimpleDateFormat er en underklasse av DateFormat som lar deg formatere og analysere datoer ved hjelp av mønsterbokstavene ovenfor. Kombiner bokstavene for å beskrive den nøyaktige strengen du vil produsere eller lese.

For eksempel:

1. Datoformat kreves: 2012.10.23 20:20:45 PSTDet riktige formatmønsteret er yyyy.MM.dd HH:mm:ss zzz.
2. Datoformat kreves: 09:30:00 AM 23-May-2012Det riktige formatmønsteret er hh:mm:ss a dd-MMM-yyyy.

Tips: Klokkebokstav. Store bokstaver. M er måned, med liten bokstav m er minutt. Store bokstaver H er en 24-timers klokke, med små bokstaver h er en 12-timers klokke. Å blande dem gir lydløst feil utdata.

Programmet nedenfor skriver ut gjeldende dato to ganger, én gang i standardformat og én gang gjennom et SimpleDateFormat-mønster:

import java.text.SimpleDateFormat;
import java.util.Date;

class TestDates_Format {
    public static void main(String args[]) {
        // Current system date and time is assigned to objDate
        Date objDate = new Date();
        System.out.println(objDate);

        // Build the target pattern and format the date
        String strDateFormat = "hh:mm:ss a dd-MMM-yyyy";
        SimpleDateFormat objSDF = new SimpleDateFormat(strDateFormat);
        System.out.println(objSDF.format(objDate));
    }
}

Utgang:

Wed Nov 29 06:31:41 UTC 2017
06:31:41 AM 29-Nov-2017

Sammenlign Datoer Eksempel

Den mest pålitelige måten å bestille to på Date objektene er compareTo() Metoden. Den returnerer et negativt heltall når innkalleren er tidligere, null når begge tidspunktene er like, og et positivt heltall når innkalleren er senere. Kodestykket nedenfor analyserer to dato-strenger og skriver ut deres relative rekkefølge:

import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;

class TestDates_Compare {
    public static void main(String args[]) throws ParseException {

        SimpleDateFormat objSDF = new SimpleDateFormat("dd-MM-yyyy");
        Date dt_1 = objSDF.parse("20-08-1981");
        Date dt_2 = objSDF.parse("12-10-2012");

        System.out.println("Date1 : " + objSDF.format(dt_1));
        System.out.println("Date2 : " + objSDF.format(dt_2));

        // compareTo returns > 0 when dt_1 is after dt_2
        if (dt_1.compareTo(dt_2) > 0) {
            System.out.println("Date 1 occurs after Date 2");
        }
        // compareTo returns < 0 when dt_1 is before dt_2
        else if (dt_1.compareTo(dt_2) < 0) {
            System.out.println("Date 1 occurs before Date 2");
        }
        // compareTo returns 0 when both dates are equal
        else {
            System.out.println("Both are the same date");
        }
    }
}

Utgang:

Date1 : 20-08-1981
Date2 : 12-10-2012
Date 1 occurs before Date 2

OBS: Den opprinnelige koden brukte mønsteret dd-mm-yyyySmå bokstaver mm bokstaven er minutt, ikke måned, så parseren produserte i stillhet feil månedsverdi. Rettelsen ovenfor bruker store bokstaver MM for måned, som er den riktige mønsterbokstaven.

Java 8 Moderne dato og klokkeslett API (java.time)

Java 8 introduserte java.time pakke, et redesignet API inspirert av Joda-Time-biblioteket. De nye klassene er uforanderlige, trådsikre og skiller den menneskelige kalenderen fra maskinens tidslinje. De vanligste typene er:

• LocalDate for en dato uten tid eller sone (for eksempel en bursdag).
• LocalTime for en veggklokketid uten dato eller sone.
• LocalDateTime for en dato og et klokkeslett uten en sone.
• ZonedDateTime for en dato og et klokkeslett med en bestemt tidssone.
• OffsetDateTime for en dato og et klokkeslett med en UTC-forskyvning, men ingen navngitt sone.
• Instant for et maskintidsstempel målt fra UNIX-epoken.
• Duration og Period for tidsbaserte og datobaserte beløp.

Eksemplet nedenfor skriver ut gjeldende dato, klokkeslett, tidsstempel og tidssone ved hjelp av det moderne API-et:

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.time.Instant;
import java.time.ZoneId;

class ModernDateDemo {
    public static void main(String args[]) {
        LocalDate today = LocalDate.now();
        LocalDateTime now = LocalDateTime.now();
        ZonedDateTime zoned = ZonedDateTime.now(ZoneId.of("Asia/Kolkata"));
        Instant epoch = Instant.now();

        System.out.println("LocalDate     : " + today);
        System.out.println("LocalDateTime : " + now);
        System.out.println("ZonedDateTime : " + zoned);
        System.out.println("Instant       : " + epoch);
    }
}

Hver type har fabrikkmetoder (now, of, parse) og uforanderlige operasjoner (plusDays, minusHours, withYear) som returnerer en ny verdi i stedet for å mutere det opprinnelige objektet.

DateTimeFormatter: Formater datoer i Modern Java

DateTimeFormatter in java.time.format erstatter SimpleDateFormatDen bruker samme stil med mønsterbokstaver, er uforanderlig og trygg å dele på tvers av tråder uten ekstra synkronisering. Klassen eksponerer også ferdige konstanter som ISO_LOCAL_DATE og ISO_ZONED_DATE_TIME for standardformater.

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

class FormatterDemo {
    public static void main(String args[]) {
        LocalDateTime now = LocalDateTime.now();

        DateTimeFormatter iso = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        DateTimeFormatter human = DateTimeFormatter.ofPattern("hh:mm:ss a dd-MMM-yyyy");

        System.out.println(now.format(iso));
        System.out.println(now.format(human));

        LocalDateTime parsed = LocalDateTime.parse("2026-07-04T09:30:00", iso);
        System.out.println("Parsed back : " + parsed);
    }
}

For å sammenligne to datoer i det moderne API-et, kall isBefore, isAftereller isEqualDisse metodene leses tydeligere enn compareTo og jobbe med alle java.time klasse.

Trådsikkerhet og beste praksis for Java Dato og klokkeslett

Begge java.util.Date og SimpleDateFormat eldre enn moderne samtidighet Java, og hver av dem har kjente fallgruver. Følg fremgangsmåtene nedenfor for å holde datohåndteringen korrekt i produksjonskoden:

• Foretrekker java.time fremfor dato og kalender. De nye typene er uforanderlige og trådsikre, og de modellerer domenet mer nøyaktig (datoer uten klokkeslett, klokkeslett uten soner og så videre).
• Ikke del et SimpleDateFormat på tvers av tråder. Klassen lagrer intern parse-tilstand og er ikke trådsikker. Pakk den inn i en ThreadLocal, synkroniser på forekomsten, eller bytt til DateTimeFormatter.
• Angi alltid en språkinnstilling. Måned- og dagnavn endres med standard JVM-språkinnstillingen, noe som lager mønstre som MMM og EEE ikke-portabel. Overfør en lokalitet eksplisitt (for eksempel Locale.ENGLISH).
• Vær tydelig om tidssoner. LocalDateTime har ingen sone, så konverter til ZonedDateTime or Instant når det nøyaktige øyeblikket er viktig, spesielt for logger, databasekolonner og nettverksnyttelaster.
• Konverter forsiktig mellom de to API-ene. Bruk date.toInstant(), Date.from(instant)og calendar.toInstant().atZone(zone) på grensen mellom eldre kode og moderne kode.
• Lagre tidsstempler i UTC. Vedhold og transmit datoer som UTC (en Instant eller en ISO 8601-streng) og konvertere til brukersonen bare ved visning.

Spørsmål og svar