Sunteți pe pagina 1din 10

Gestionarea datei și a timpului este unul dintre conceptele de bază ale

oricărui limbaj de programare. Deși gestionarea datei și a timpului


poate părea o rutină și o sarcină simplă la prima vedere, nu este așa.
Dacă privim mai îndeaproape, vom putea vedea complexitatea acestei
chestiuni. Avem ani bisecți, fusuri orare și ora de vară și de iarnă. Dacă
la toate acestea mai adăugăm și faptul că un computer ”înțelege”
conceptul de timp complet diferit de noi, confruntarea cu acest
domeniu poate fi problematică, mai ales pentru începători.

Pentru a simplifica gestionarea datei și a timpului, Java 8 introduce un


Date and Time API complet nou. Până la versiunea 8, gestionarea datei
și a timpului era confuză, în special pentru programatorii
neexperimentați. Din acest motiv, a fost introdus un pachet complet
nou pentru gestionarea datei și a timpului: java.time.

Există două moduri diferite de a reprezenta timpul. Unul este cunoscut


de toată lumea, cel obișnuit pentru oameni, în timp ce celălalt este
modul în care mașinile ”văd” timpul. Oamenii percep timpul în modul
bine cunoscut, exprimându-l în ani, luni, zile, ore, minute și secunde.
Cu toate acestea, mașinile nu sunt familiarizate cu acest mod de
exprimare a timpului. Mașinile măsoară timpul dintr-un moment
(punctul de început) și îl exprimă într-o unitate de timp specifică (de
obicei, nanosecunde). Pachetul java.time posedă diverse clase care se
pot utiliza pentru a gestiona timpul. Unele dintre ele sunt utilizate
pentru a exprima timpul într-un format inteligibil pentru oameni, iar
altele, în formate inteligibile pentru mașini.

LocalDate

Dacă dorim să gestionăm doar data în formatul inteligibil pentru


oameni, putem utiliza clasa LocalDate. Haideți să vedem cum putem
citi data curentă:

public static void main(String[] args) {


System.out.println(LocalDate.now());
}

Pentru ca acest cod de mai sus să funcționeze, trebuie să adăugăm


pachetul:

import java.time.LocalDate;

După execuția codului, ieșirea va afișa data curentă. Ce am făcut mai


exact cu această metodă? Să privim linia următoare:

LocalDate now = LocalDate.now();

În linia anterioară, am utilizat metoda statică now a clasei LocalDate


pentru a crea tipul LocalDate. Aceasta înseamnă că am obținut
variabila now care este un obiect pe care îl putem utiliza pentru
manipulările ulterioare. De exemplu, putem extrage un an din această
variabilă:

now.getYear();

Dacă dorim să definim noi înșine o dată utilizând clasa LocalDate, o


putem face în modul următor:

LocalDate date = LocalDate.of(2000, 11, 20);

Acordați atenție faptului că am utilizat metoda of pentru a crea un


obiect de tipul LocalDate, care acceptă anul, luna și ziua ca parametri.
Toți parametrii sunt valori întregi de tipul int.

LocalTime

Analog cu manipularea datei, există de asemenea și o clasă cu care


putem manipula doar timpul: LocalTime. Această clasă este ideală
pentru manipularea timpului într-un format inteligibil pentru om.

public static void main(String[] args) throws IOException {


LocalTime time = LocalTime.now();
System.out.println("Hour: " + time.getHour() + " Minutes: " + time.getMinute() + " Seconds: "
+ time.getSecond());
}
Codul de mai sus va afișa timpul curent la ieșire. Am obținut afișajul
prin extragerea componentelor timpului, la fel ca în cazul clasei
anterioare pentru gestionarea datei.

LocalDataTime

În pachetul java.time se află o clasă care unifică utilizarea datei și a


timpului: LocalDateTime.

Pentru a obține data și timpul curent, putem utiliza funcția now.

System.out.println(LocalDateTime.now());

Timpul va fi afișat în următorul format:

2014-09-03T10:34:59.507

De asemenea, clasa LocalDateTime are mai multe metode și atribute


încorporate. Haideți să le vedem:

public static void main(String[] args) {

LocalDateTime dateTime = LocalDateTime.now();


int year = dateTime.getYear();
int month = dateTime. getMonthValue();
int day = dateTime.getDayOfMonth();

int hour = dateTime.getHour();


int minutes = dateTime.getMinute();
int seconds = dateTime.getSecond();

System.out.println("Today is " + dateTime.getMonth() + " " + day + ", " + year);


System.out.println("It is " + hour + " hours " + minutes + " minutes and " + seconds + " seconds"
);

System.out.println("6 months from now: " + dateTime.plusMonths(6));


System.out.println("6 months ago: " + dateTime.minusMonths(6));

În codul de mai sus, putem vedea cum putem extrage valorile


segmentelor specifice de timp din obiectul dataTime, care este de tip
LocalDateTime. Acordați atenție faptului că am utilizat două metode în
două situații diferite pentru a extrage luna. Dacă dorim numărul ordinal
al unei luni, utilizăm metoda getMonthValue, iar dacă dorim să obținem
denumirea lunii în formă textuală, putem utiliza metoda getMonth.

De asemenea, în codul de mai sus, am utilizat tehnicile pentru


adăugarea sau înlăturarea unui anumit timp. În acest scop, am utilizat
metodele plusMonths și minusMonths pentru a dăuga sau elimina luni
dintr-o dată deja creată.

Dacă am dori să prezentăm un moment temporal în mod independent,


cu ajutorul clasei LocalDateTime, o vom putea face în câteva moduri.

LocalDate localDate = LocalDate.of(1999, 12, 13);


LocalTime localTime = LocalTime.of(17, 50);

LocalDateTime localDateTime = LocalDateTime.of(localDate,


localTime);

System.out.println(localDateTime);

În acest mod, am expediat metodei parametrii ce reprezintă obiectele


clasei cu care ne-am familiarizat deja. Bineînțeles, putem crea o
variabilă a timpului în mod direct, prin expedierea valorilor.

LocalDateTime localDateTime = LocalDateTime.of(1999, 12, 13,


17, 50);
System.out.println(localDateTime);

Vom obține același lucru cu toate metodele menționate anterior.


Instant

Clasele despre care am discutat până acum sunt folosite pentru a


gestiona data și timpul într-un format inteligibil pentru oameni. Am
menționat deja că un calculator înțelege timpul într-un mod complet
diferit. În pachetul java.time, există clasa Instant utilizată pentru a
prezenta timpul scurs în nanosecunde, începând cu prima secundă a
zilei de 1 ianuarie 1970 (această dată mai este cunoscută și ca
EPOCH). Această clasă este foarte utilă pentru a genera reprezentările
unor momente temporale în fomatul destinat mașinilor.

Instant instant = Instant.now();


System.out.println(instant.toString());

În acest mod, am creat o variabilă de tipul Instant și am utilizat metoda


deja familiară, now, pentru a obține timpul curent. Clasa Instant
reimplementează metoda toString care afișează valoarea unei variabile
într-un format inteligibil.

Clasa Instant are mai multe metode încorporate pentru manipularea


obiectelor de acest tip.

Instant instant = Instant.now();


Thread.sleep(1000);
long period = instant.until(Instant.now(),
ChronoUnit.SECONDS);
System.out.println(period);

Cu ajutorul codului de mai sus, am calculat perioada scursă dintre două


momente temporale, prin implementarea metodei until a clasei Instant.
Pentru a crea un interval între aceste momente, am pus execuția
programului pe pauză timp de o secundă, utilizând următoarea linie:

Thread.sleep(1000);

La ieșire vom obține afișarea perioadei în secunde.

Uneori va trebui să convertim un obiect de tipul Instant într-un obiect


cu un format temporal inteligibil.

Instant instant = Instant.now();


LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
System.out.printf("%s %d %d at %d:%d%n", ldt.getMonth(), ldt.getDayOfMonth(),ldt.getY
ear(), ldt.getHour(), ldt.getMinute());

Cu codul de mai sus, am convertit obiectul instant în tipul


LocalDateTime, utilizând metoda ofInstant și expediind metodei
obiectul instant și fusul orar implicit. În timpul afișării timpului, am
specificat mai întâi caracterele ce vor reprezenta valorile anumitor
componente ale timpului, iar apoi am accesat metodele. De exemplu,
cu prima secvență %s, am specificat că pe această poziție de va afla o
valoare textuală de tip String și care va fi determinată de valoarea
returnată a primei metode (ldt.getMonth).

Formatarea și parsarea

În timpul creării unui program, va trebui uneori să parsăm o valoare


textuală de tip String într-unul dintre obiectele din pachetul java.time.
Formatarea se poate face cu ajutorul clasei DateTimeFormatter.

public static void main(String[] args) {

String in = "19880505";
LocalDate date = LocalDate.parse(in, DateTimeFormatter.BASIC_ISO_DATE);

System.out.println(date);
}

În exemplul de mai sus, putem vedea o utilizare de bază a acestei


clase, unde am parsat data din string cu metoda parse a clasei
LocalDate. În acest exemplu, am utilizat tipul de bază al formatării,
BASIC_ISO_DATE. Stringul pe care dorim să-l parsăm cu această
metodă trebuie să arate astfel: yyyymmdd.

Putem crea o regulă proprie pentru parsarea stringului.

public static void main(String[] args) {

String in = "05 05 1988";

try {

DateTimeFormatter formatter
= DateTimeFormatter.ofPattern("dd MM yyyy");
LocalDate date = LocalDate.parse(in, formatter);

System.out.println(date);

} catch (Exception exc) {


System.out.println(exc);
}

Vom obține următoarea ieșire:

1988-05-05

Se recomadă utilizarea blocurilor try/catch, fiindcă în cazul în care


parsarea eșuează, va apărea o excepție.

Putem vedea că Java formatează în mod automat data conform


anumitor reguli. Codul de mai sus, unde mai întâi avem anul, apoi luna
și ziua, nu este cel mai bun format pentru condițiile noastre. De aceea
există posibilitatea de a formata data. Haideți să vedem cum putem
efectua o modificare a codului de mai sus pentru ca ieșirea să fie
formatată diferit:
public static void main(String[] args) {

String in = "05 05 1988";

try {

DateTimeFormatter formatter
= DateTimeFormatter.ofPattern("dd MM yyyy");

DateTimeFormatter formatter2
= DateTimeFormatter.ofPattern("dd MMM yyyy");
LocalDate date = LocalDate.parse(in, formatter);

System.out.println(date.format(formatter2));

}
catch (Exception exc) {
System.out.println(exc);
}
}

Acordați atenție asupra faptului că, la ieșire, veți obține o denumire


textuală a lunii, în funcție de regiunea pe care ați specificat-o pe
sistemul unde codul este executat.

Putem instanția un obiect al clasei DateTimeFormatter în cadrul


apelului metodei parse:

LocalDate date = LocalDate.parse(in,


DateTimeFormatter.ofPattern("dd MMM yyyy"));

Iată câteva simboluri ce pot fi utilizate pentru parsarea și formatarea


stringurilor:

Simbol Semnificație
Y an
D zi a anului
M lună a anului
d zi a lunii
h ore (1-12)
H ore (1-24)
m minute
s secunde

Perioada

O funcție foarte utilă, care se poate utiliza în timpul scrierii unui


program, este calcularea perioadei de timp. În următorul exemplu, am
implementat câteva dintre funcțiile pentru calcularea periodei de timp,
aflate în pachetul java.time.

public static void main(String[] args) {

LocalDate now = LocalDate.now();


LocalDate birthday = LocalDate.of(1975, Month.MAY, 1);

Period p = Period.between(birthday, now);


long p2 = ChronoUnit.DAYS.between(birthday, now);
long p3 = ChronoUnit.MONTHS.between(birthday, now);

System.out.println("You are " + p.getYears() + " years, " + p.getMonths() + " months, and " + p.
getDays() + " days old. (" + p2 + " days total or " + p3 + " months)");
}

În codul de mai sus, am inițializat două obiecte ale clasei LocalDate:


now și birthday. Pentru a calcula perioada dintre aceste două date,
vom utiliza clasa Period și metoda between a acestei clase. Această
metodă acceptă ca parametri două obiecte create pentru care este
necesar să se determine perioada de timp scurs.

În codul de mai sus am utilizat enumerarea CronoUnit și metoda sa


between. Această metodă este foarte utilă când trebuie să calculăm
diferența dintre două puncte temporale, dar exprimată într-o singură
unitate de timp (de exemplu, doar în zile sau doar în luni).

După execuția codului de mai sus, vom obține următoarea ieșire:

You are 38 years, 10 months, and 2 days old. (14186 days or


466 months total)

Durata

Calasa Period funcționează numai în contextul datei (ani, luni și zile).


Dacă dorim să exprimăm o anumită perioadă în ore, minute sau
secunde, putem utiliza clasa Duration.

LocalTime time1 = LocalTime.now();


Thread.sleep(1000);
LocalTime time2 = LocalTime.now();

Duration duration = Duration.between(time1, time2);

System.out.println(duration.getSeconds());

La fel ca în situația anterioară, cu metoda between vom obține timpul


scurs între două puncte temporale.

S-ar putea să vă placă și