Java Data e ora

Gestione di date e orari in Java È una parte di routine della creazione della logica di pianificazione, dei timestamp di registrazione, dei report e delle tracce di controllo. Prima di scrivere qualsiasi codice, è utile conoscere i parametri che compongono una data:

• Migliori anno (a due o quattro cifre).
• Migliori mese (come due cifre, come le prime tre lettere del mese o come il nome completo del mese).
• Migliori quando (il numero effettivo del giorno del mese).
• Migliori giorno (il nome del giorno nella data indicata, ad esempio dom, lun, mar).

Java Espone molti altri parametri che descrivono un momento sulla linea temporale, tra cui l'era, la settimana dell'anno, il fuso orario e l'offset. Le sezioni seguenti illustrano ciascuno di essi con esempi eseguibili.

Visualizza la data in Java

Java fornisce un Date classe in java.util pacchetto. La classe memorizza un istante specifico nel tempo con precisione al millisecondo e offre metodi di supporto per stampare, confrontare e formattare tale istante. Per ottenere la data e l'ora correnti, istanziare la classe con il suo costruttore predefinito:

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

Produzione:

Wed Nov 29 06:36:22 UTC 2017

L'esempio stampa la data nel formato predefinito toString. Per visualizzare lo stesso istante in un modello diverso, è necessario prima comprendere le lettere di formattazione che Java utilizza.

SimpleDateFormat: analizza e formatta le date

Migliori SimpleDateFormat classe in java.text converte un Date oggetto in una stringa formattata e analizza una stringa formattata di nuovo in un DateUtilizza lettere schematiche che corrispondono a una data o a un'ora. La tabella seguente elenca tutte le lettere supportate:

Non è necessario memorizzare l'intera tabella. Consultatela ogni volta che create un nuovo schema.

Come utilizzare SimpleDateFormat

SimpleDateFormat è una sottoclasse di DateFormat che consente di formattare e analizzare le date utilizzando le lettere del modello sopra. Combina le lettere per descrivere la stringa esatta che desideri produrre o leggere.

Per esempio:

1. Formato data richiesto: 2012.10.23 20:20:45 PST. Il modello di formato appropriato è yyyy.MM.dd HH:mm:ss zzz.
2. Formato data richiesto: 09:30:00 AM 23-May-2012. Il modello di formato appropriato è hh:mm:ss a dd-MMM-yyyy.

Suggerimento: Attenzione alle maiuscole e minuscole. M è mese, minuscolo m è minuto. Maiuscolo H è un orologio a 24 ore, minuscolo h è un orologio a 12 ore. Scambiandoli si ottiene un risultato errato senza alcun rumore.

Il programma seguente stampa la data corrente due volte: una volta nel formato predefinito e una volta utilizzando il formato SimpleDateFormat:

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

Produzione:

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

Esempio di confronto delle date

Il modo più affidabile per ordinare due Date gli oggetti sono compareTo() metodo. Restituisce un numero intero negativo quando il chiamante è precedente, zero quando entrambi gli istanti sono uguali e un numero intero positivo quando il chiamante è successivo. Il frammento di codice seguente analizza due stringhe di data e ne stampa l'ordine relativo:

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

Produzione:

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

Nota: Il codice originale utilizzava il modello dd-mm-yyyy. La minuscola mm La lettera indica il minuto, non il mese, quindi il parser ha prodotto silenziosamente un valore errato per il mese. La correzione sopra utilizza le maiuscole. MM per il mese, che è la lettera corretta del modello.

Java 8 API moderne per data e ora (java.time)

Java 8 ha introdotto il java.time pacchetto, un'API riprogettata ispirata alla libreria Joda-Time. Le nuove classi sono immutabili, thread-safe e separano il calendario umano dalla timeline della macchina. I tipi più comuni sono:

• LocalDate per una data senza orario o fuso orario (ad esempio, un compleanno).
• LocalTime per un orologio da parete senza data né fuso orario.
• LocalDateTime per una data e un'ora senza fuso orario.
• ZonedDateTime per una data e un'ora con un fuso orario specifico.
• OffsetDateTime per una data e un'ora con un offset UTC ma senza un fuso orario specificato.
• Instant per un timestamp della macchina misurato dall'epoca UNIX.
• Duration and Period per importi basati sul tempo e sulla data.

L'esempio seguente visualizza la data, l'ora, il timestamp e il fuso orario correnti utilizzando l'API moderna:

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

Ogni tipo ha metodi di fabbrica (now, of, parse) e operazioni immutabili (plusDays, minusHours, withYear) che restituiscono un nuovo valore invece di modificare l'oggetto originale.

DateTimeFormatter: Formatta le date in formato moderno Java

DateTimeFormatter in java.time.format sostituisce SimpleDateFormatUtilizza lo stesso stile di lettere del modello, è immutabile ed è sicuro da condividere tra thread senza sincronizzazione aggiuntiva. La classe espone anche costanti predefinite come ISO_LOCAL_DATE and ISO_ZONED_DATE_TIME per formati standard.

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

Per confrontare due date nell'API moderna, chiamare isBefore, isAfter, o isEqualQuesti metodi sono più chiari di compareTo e lavorare con ogni java.time classe.

Sicurezza dei fili e migliori pratiche per Java Data e ora

Entrambi i progetti editoriali di java.util.Date and SimpleDateFormat precedere il moderno contemporaneo Javae ognuna presenta delle insidie ​​note. Segui le procedure descritte di seguito per gestire correttamente le date nel codice di produzione:

• Preferisco java.time a Date e Calendar. I nuovi tipi sono immutabili e thread-safe, e modellano il dominio in modo più accurato (date senza orari, orari senza fusi orari e così via).
• Non condividere un oggetto SimpleDateFormat tra thread diversi. La classe memorizza lo stato di analisi interno e non è thread-safe. Avvolgila in un ThreadLocal, sincronizzare sull'istanza o passare a DateTimeFormatter.
• Specificare sempre le impostazioni locali. I nomi dei mesi e dei giorni cambiano con le impostazioni locali predefinite della JVM, il che rende possibili modelli come MMM and EEE non portatile. Passa esplicitamente una locale (ad esempio, Locale.ENGLISH).
• Siate espliciti riguardo ai fusi orari. LocalDateTime non ha zona, quindi converti in ZonedDateTime or Instant quando il momento preciso è importante, soprattutto per i log, le colonne del database e i payload di rete.
• Convertire tra le due API con attenzione. Usa il date.toInstant(), Date.from(instant)e calendar.toInstant().atZone(zone) al confine tra codice legacy e codice moderno.
• Memorizza i timestamp in formato UTC. Perseverare e transmit date come UTC (un Instant o una stringa ISO 8601) e convertire nella zona utente solo durante la visualizzazione.

DOMANDE FREQUENTI