Italiano

Tutorial Java

Dichiarazioni di controllo Java

Programmazione orientata agli oggetti

Classi incorporate Java

Gestione dei file Java

Errori e Eccezioni Java

Java Multithreading

Sincronizzazione di Java

Rete Java

Collections Java

Interfacce Java

Strutture dati Java

Algoritmi delle Collections Java

Java avanzato

Varie Java

Riferimenti alle classi Java

Java 8 - Nuova API Data-Time

Ciao là, futuri maghi Java! ? Oggi ci imbarcheremo in un viaggio emozionante attraverso il magico regno dell'API Data-Time di Java. Non preoccuparti se non hai mai scritto una riga di codice prima - inizieremo dal principio e procederemo insieme. Entro la fine di questa lezione, sarai in grado di manipolare date e ore come un professionista! Allora, entriamo nel dettaglio!

Java - Datetime Api

Introduzione all'API Data-Time di Java

Immagina di costruire una macchina del tempo (molto cool, vero?). Per farla funzionare, dovresti gestire date e ore con precisione. Proprio questo è ciò che ci aiuta a fare l'API Data-Time di Java nei nostri programmi. È come avere un orologio e un calendario super-accurati in uno!

Perché una Nuova API?

Prima di addentrarci nei dettagli, potresti chiederti: "Perché Java ha creato una nuova API Data-Time?" Bene, lasciami raccontarti una piccola storia.

Un tempo (prima di Java 8), gli sviluppatori erano costretti a usare le vecchie classi java.util.Date e java.util.Calendar. Queste erano come usare un vecchio orologio arrugginito - funzionavano, ma avevano molti problemi. Erano difficili da usare, non thread-safe (cioè potevano causare problemi in programmi complessi) e non gestivano bene i fusi orari.

Quindi, la squadra di Java ha deciso di creare una nuova, splendida API che risolvesse tutti questi problemi. E così, il pacchetto java.time è nato con Java 8!

API Data-Time Locale di Java

Iniziamo con le basi. L'API Data-Time Locale ci aiuta a lavorare con date e ore senza preoccuparsi dei fusi orari. È come avere un semplice orologio e calendario sulla tua scrivania.

LocalDate

LocalDate rappresenta una data senza fuso orario. Vediamo come usarla:

import java.time.LocalDate;

public class DateExample {
public static void main(String[] args) {
LocalDate today = LocalDate.now();
System.out.println("Oggi è: " + today);

LocalDate specificDate = LocalDate.of(2023, 6, 15);
System.out.println("Una data specifica: " + specificDate);
}
}

In questo esempio, stiamo facendo due cose:

  1. Stiamo ottenendo la data odierna usando LocalDate.now().
  2. Stiamo creando una data specifica (15 giugno 2023) usando LocalDate.of().

Quando esegui questo codice, vedrai la data odierna e la data specifica che abbiamo creato stampate.

LocalTime

LocalTime rappresenta un'ora senza data o fuso orario. Ecco come possiamo usarla:

import java.time.LocalTime;

public class TimeExample {
public static void main(String[] args) {
LocalTime now = LocalTime.now();
System.out.println("L'ora attuale è: " + now);

LocalTime specificTime = LocalTime.of(14, 30, 45);
System.out.println("Un'ora specifica: " + specificTime);
}
}

In questo esempio:

  1. Stiamo ottenendo l'ora attuale usando LocalTime.now().
  2. Stiamo creando un'ora specifica (2:30:45 PM) usando LocalTime.of().

LocalDateTime

LocalDateTime combina sia la data che l'ora, ma sempre senza fuso orario. È come avere un orologio che mostra anche la data. Ecco come usarlo:

import java.time.LocalDateTime;

public class DateTimeExample {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
System.out.println("Data e ora attuale: " + now);

LocalDateTime specificDateTime = LocalDateTime.of(2023, 6, 15, 14, 30, 45);
System.out.println("Una data e ora specifica: " + specificDateTime);
}
}

In questo esempio:

  1. Stiamo ottenendo la data e l'ora attuale usando LocalDateTime.now().
  2. Stiamo creando una data e ora specifica (15 giugno 2023, alle 2:30:45 PM) usando LocalDateTime.of().

API Data-Time Zonizzato di Java

Ora, aggiungiamo un po' di pepe al nostro tempo machine - i fusi orari! L'API Data-Time Zonizzato ci aiuta a lavorare con date e ore tenendo conto dei diversi fusi orari.

ZonedDateTime

ZonedDateTime rappresenta una data-ora con un fuso orario. È come avere un orologio mondiale che mostra diverse ore per diverse parti del mondo.

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class ZonedDateTimeExample {
public static void main(String[] args) {
ZonedDateTime nowInSystemTZ = ZonedDateTime.now();
System.out.println("Data-ora attuale nel fuso orario del sistema: " + nowInSystemTZ);

ZonedDateTime nowInParis = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println("Data-ora attuale a Parigi: " + nowInParis);
}
}

In questo esempio:

  1. Stiamo ottenendo la data-ora attuale nel fuso orario del sistema usando ZonedDateTime.now().
  2. Stiamo ottenendo la data-ora attuale a Parigi usando ZonedDateTime.now(ZoneId.of("Europe/Paris")).

Enum ChronoUnit di Java

L'enum ChronoUnit fornisce un set di periodi standard di date e unità di tempo. È come avere diversi strumenti di misurazione del tempo - secondi, minuti, ore, giorni, settimane, mesi, anni, e così via.

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitExample {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
LocalDateTime futureDateTime = now.plus(1, ChronoUnit.WEEKS);

long daysBetween = ChronoUnit.DAYS.between(now, futureDateTime);
System.out.println("Giorni tra oggi e una settimana da oggi: " + daysBetween);
}
}

In questo esempio:

  1. Stiamo aggiungendo una settimana alla data-ora attuale usando plus(1, ChronoUnit.WEEKS).
  2. Stiamo calcolando il numero di giorni tra oggi e una settimana da oggi usando ChronoUnit.DAYS.between().

Period e Duration di Java

Period e Duration vengono utilizzati per rappresentare quantità di tempo. Pensa a Period come alla differenza tra due date su un calendario, e a Duration come al tempo mostrato su un cronometro.

import java.time.LocalDate;
import java.time.Period;
import java.time.Duration;
import java.time.LocalTime;

public class PeriodDurationExample {
public static void main(String[] args) {
LocalDate date1 = LocalDate.of(2023, 1, 1);
LocalDate date2 = LocalDate.of(2023, 12, 31);
Period period = Period.between(date1, date2);
System.out.println("Periodo tra " + date1 + " e " + date2 + ": " + period);

LocalTime time1 = LocalTime.of(9, 0);
LocalTime time2 = LocalTime.of(17, 30);
Duration duration = Duration.between(time1, time2);
System.out.println("Durata tra " + time1 + " e " + time2 + ": " + duration);
}
}

In questo esempio:

  1. Stiamo calcolando il periodo tra due date usando Period.between().
  2. Stiamo calcolando la durata tra due ore usando Duration.between().

Temporal Adjusters di Java

I Temporal Adjusters sono come bacchette magiche per le date. Lasciano modificare le date in modi utili, come trovare il lunedì successivo o l'ultimo giorno del mese.

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

public class TemporalAdjustersExample {
public static void main(String[] args) {
LocalDate date = LocalDate.now();
LocalDate nextMonday = date.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
System.out.println("Lunedì successivo: " + nextMonday);

LocalDate lastDayOfMonth = date.with(TemporalAdjusters.lastDayOfMonth());
System.out.println("Ultimo giorno di questo mese: " + lastDayOfMonth);
}
}

In questo esempio:

  1. Stiamo trovando la data del lunedì successivo usando TemporalAdjusters.next(DayOfWeek.MONDAY).
  2. Stiamo trovando l'ultimo giorno del mese corrente usando TemporalAdjusters.lastDayOfMonth().

Retrocompatibilità

Ora, potresti chiederti: "E tutto il vecchio codice che usa le vecchie classi di data e ora?" Non preoccuparti! Java ha pensato anche a questo. La nuova API fornisce metodi per convertire tra le vecchie e le nuove classi di data-ora.

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class BackwardCompatibilityExample {
public static void main(String[] args) {
// Convertire vecchia Date in nuova LocalDateTime
Date oldDate = new Date();
LocalDateTime newDateTime = LocalDateTime.ofInstant(oldDate.toInstant(), ZoneId.systemDefault());
System.out.println("Vecchia Date: " + oldDate);
System.out.println("Nuova LocalDateTime: " + newDateTime);

// Convertire nuova LocalDateTime in vecchia Date
LocalDateTime localDateTime = LocalDateTime.now();
Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
System.out.println("Nuova LocalDateTime: " + localDateTime);
System.out.println("Vecchia Date: " + date);
}
}

In questo esempio:

  1. Stiamo convertendo un oggetto vecchia Date in una nuova LocalDateTime.
  2. Stiamo convertendo una nuova LocalDateTime in una vecchia Date.

Questa retrocompatibilità ci permette di continuare a lavorare con il vecchio codice Java mentre godiamo dei benefici della nuova API Data-Time.

Conclusione

Complimenti! Hai appena fatto i tuoi primi passi nel mondo dell'API Data-Time di Java. Abbiamo coperto molto terreno, dai concetti di base di gestione delle date e ore fino a concetti più avanzati come fusi orari e temporal adjusters.

Ricorda, come ogni abilità, padroneggiare la gestione delle date e ore in Java richiede pratica. Non scoraggiarti se all'inizio ti sembra överwhelming - anche gli sviluppatori esperti a volte devono cercare come usare queste classi!

Continua a sperimentare con questi esempi, a modificarli e a vedere cosa succede. Prima di sapere, sarai in grado di manipolare date e ore come un vero viaggiatore del tempo Java!

Buon codice e possa il tuo timing sempre essere perfetto! ⏰?

Credits: Image by storyset

Tutorial precedente:
Java - Stream
Prossimo tutorial:
Java 8 - Nuove Funzionalità