Java Datum en tijd

Het verwerken van datums en tijden in Java Het is een standaardonderdeel van het bouwen van planningslogica, het vastleggen van tijdstempels, het genereren van rapporten en het bijhouden van auditsporen. Voordat je code schrijft, is het handig om te weten uit welke parameters een datum bestaat:

• De jaar (in twee of vier cijfers).
• De maand (als twee cijfers, als de eerste drie letters van de maand, of als de volledige maandnaam).
• De gegevens (het daadwerkelijke dagnummer van de maand).
• De dag (de naam van de dag op de betreffende datum, zoals zo, ma, di).

Java Dit toont vele andere parameters die een moment op de tijdlijn beschrijven, waaronder tijdperk, week van het jaar, tijdzone en offset. De onderstaande secties behandelen elk van deze parameters met uitvoerbare voorbeelden.

Datum weergeven in Java

Java biedt Date klasse in de java.util pakket. De klasse slaat een specifiek tijdstip op met een nauwkeurigheid van milliseconden en biedt hulpmethoden om dat tijdstip af te drukken, te vergelijken en te formatteren. Om de huidige datum en tijd te verkrijgen, instantieert u de klasse met de standaardconstructor:

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

Output:

Wed Nov 29 06:36:22 UTC 2017

Het voorbeeld print de datum in de standaard toString-indeling. Om hetzelfde moment in een ander formaat weer te geven, moet u eerst de opmaaktekens begrijpen die Java toepassingen.

SimpleDateFormat: datums parseren en formatteren

De SimpleDateFormat klasse in java.text converteert naar Date zet een object om in een opgemaakte tekenreeks en parseert een opgemaakte tekenreeks terug naar een DateHet maakt gebruik van patroonletters die corresponderen met een datum- of tijdcomponent. De onderstaande tabel geeft een overzicht van alle ondersteunde letters:

Je hoeft niet de hele tabel uit je hoofd te leren. Raadpleeg hem wanneer je een nieuw patroon maakt.

Hoe SimpleDateFormat te gebruiken

SimpleDateFormat is een subklasse van DateFormat Hiermee kunt u datums formatteren en parseren met behulp van de bovenstaande patroonletters. Combineer de letters om de exacte tekenreeks te beschrijven die u wilt produceren of lezen.

Bijvoorbeeld:

1. Vereiste datumindeling: 2012.10.23 20:20:45 PSTHet juiste opmaakpatroon is yyyy.MM.dd HH:mm:ss zzz.
2. Vereiste datumindeling: 09:30:00 AM 23-May-2012Het juiste opmaakpatroon is hh:mm:ss a dd-MMM-yyyy.

Tip: Let op de lettervorm. Hoofdletters M is maand, kleine letter m is klein. Hoofdletter H is een 24-uursklok, kleine letter h Het is een 12-uursklok. Als je ze door elkaar haalt, krijg je ongemerkt een verkeerde output.

Het onderstaande programma print de huidige datum twee keer, één keer in de standaardindeling en één keer met behulp van een SimpleDateFormat-patroon:

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

Output:

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

Voorbeeld van datums vergelijken

De meest betrouwbare manier om twee te bestellen Date objecten is de compareTo() methode. Deze retourneert een negatief geheel getal als de aanroeper eerder is, nul als beide tijdstippen gelijk zijn en een positief geheel getal als de aanroeper later is. Het onderstaande codefragment analyseert twee datumreeksen en print hun relatieve volgorde:

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

Output:

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

Let op: De oorspronkelijke code gebruikte het patroon dd-mm-yyyy. De kleine letters mm De letter staat voor minuut, niet voor maand, dus de parser gaf stilletjes de verkeerde maandwaarde weer. De bovenstaande oplossing gebruikt hoofdletters. MM voor de maand, wat de juiste patroonletter is.

Java 8 Moderne datum- en tijd-API (java.time)

Java 8 introduceerde de java.time Dit pakket biedt een herontworpen API, geïnspireerd op de Joda-Time-bibliotheek. De nieuwe klassen zijn onveranderlijk, thread-safe en scheiden de menselijke kalender van de machinetijdlijn. De meest voorkomende typen zijn:

• LocalDate voor een datum zonder tijd of tijdzone (bijvoorbeeld een verjaardag).
• LocalTime voor een wandklok met tijdsaanduiding zonder datum of tijdzone.
• LocalDateTime voor een datum en tijd zonder tijdzone.
• ZonedDateTime voor een datum en tijd met een specifieke tijdzone.
• OffsetDateTime voor een datum en tijd met een UTC-offset, maar zonder benoemde tijdzone.
• Instant voor een machinetijdstempel gemeten vanaf de UNIX-epoch.
• Duration en Period voor tijds- en datumgebonden bedragen.

Het onderstaande voorbeeld toont de huidige datum, tijd, tijdstempel en tijdzone met behulp van de moderne API:

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

Elk type heeft fabrieksmethoden (now, of, parse) en onveranderlijke bewerkingen (plusDays, minusHours, withYear) die een nieuwe waarde retourneren in plaats van het oorspronkelijke object te wijzigen.

DateTimeFormatter: Datums formatteren in moderne tijd Java

DateTimeFormatter in java.time.format vervangt SimpleDateFormatHet gebruikt dezelfde stijl van patroonletters, is onveranderlijk en kan veilig tussen threads worden gedeeld zonder extra synchronisatie. De klasse biedt ook kant-en-klare constanten zoals ISO_LOCAL_DATE en ISO_ZONED_DATE_TIME voor standaardformaten.

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

Om twee datums te vergelijken in de moderne API, kunt u de volgende aanroep gebruiken: isBefore, isAfterof isEqualDeze methoden zijn duidelijker leesbaar dan compareTo en samenwerken met iedereen java.time klasse.

Draadveiligheid en beste praktijken voor Java Datum en tijd

Beiden java.util.Date en SimpleDateFormat dateren van vóór de moderne gelijktijdige JavaEn elk daarvan kent zijn eigen valkuilen. Volg de onderstaande werkwijzen om de correcte verwerking van datums in productiecode te waarborgen:

• Geef de voorkeur aan java.time boven Date en Calendar. De nieuwe gegevenstypen zijn onveranderlijk en thread-safe, en ze modelleren het domein nauwkeuriger (datums zonder tijden, tijden zonder tijdzones, enzovoort).
• Deel geen SimpleDateFormat tussen threads. De klasse slaat interne parse-status op en is niet thread-safe. Wikkel deze in een ThreadLocal, synchroniseren op de instantie, of overschakelen naar DateTimeFormatter.
• Geef altijd een landinstelling op. De namen van de maanden en dagen veranderen met de standaardlocale van de JVM, waardoor patronen zoals MMM en EEE niet-draagbaar. Geef expliciet een landinstelling op (bijvoorbeeld, Locale.ENGLISH).
• Geef de tijdzones duidelijk aan. LocalDateTime heeft geen zone, dus converteer naar ZonedDateTime or Instant Wanneer het exacte moment ertoe doet, vooral bij logbestanden, databasekolommen en netwerkdata.
• Converteer zorgvuldig tussen de twee API's. Gebruik date.toInstant(), Date.from(instant)en calendar.toInstant().atZone(zone) Op de grens tussen verouderde en moderne code.
• Sla tijdstempels op in UTC. Volhard en transmit datums als UTC (een Instant of een ISO 8601-string) en converteer alleen naar de gebruikerszone wanneer deze wordt weergegeven.

Veelgestelde vragen