Laboratorul 6: Colecții, Tipuri de Date Speciale și Utilitare

• Autori: Florian-Luis Micu , Sorina-Anamaria Buf , Ștefan Cocioran
• Data publicării: 10.11.2025
• Data ultimei modificări: 10.11.2025

Pe parcursul laboratoarelor și temelor ați folosit structuri de date oferite de API-ul Java. În cadrul acestui laborator le vom aprofunda.

Aspectele urmărite sunt:

• tipuri Wrapper peste primitive.
• lucrul cu cele trei tipuri principale de colecții din Java: List, Set, Queue, Map.
• cunoașterea diferențelor dintre implementările colecțiilor (eficiență, sortare, ordonare etc).
• compararea elementelor unor colecții.
• contractul equals-hashCode.

Aspectele bonus urmărite sunt:

• utilitare din biblioteca Math.
• lucrul cu date și ore.
• folosirea tipurilor BigInteger și BigDecimal.

În Java există o separare fundamentală între:

• Tipurile primitive, utilizate pentru operații rapide și eficiente (int, double, boolean, char etc.);
• Tipurile de clasă (obiecte), care oferă funcționalități suplimentare și fac parte din ierarhia java.lang.Object.

Obiectele de tip wrapper oferă funcționalități suplimentare sub forma unor metode (ex. rotateLeft(), toHex() etc.), însă, spre deosebire de tipurile primitive, acestea sunt gestionate de Garbage Collector, ceea ce poate face execuția mai lentă.

Din aceste motive, Java a ales să păstreze tipurile primitive pentru a evita costurile suplimentare ale obiectelor, mai ales în calculele numerice intensive.

Pentru a permite utilizarea valorilor primitive în contexte ce necesită obiecte (de exemplu, în colecții despre care vom vorbi mai jos), Java oferă clase wrapper dedicate fiecărui tip primitiv.

Un obiect wrapper poate fi construit:

• dintr-o valoare primitivă
• dintr-un șir de caractere (String) care reprezintă valoarea numerică.

Float pi = new Float(3.14);
Float pi2 = new Float("3.14");

Dacă șirul nu poate fi convertit într-o valoare numerică validă, se afișează o eroare la run-time de tip NumberFormatException.

Toate clasele numerice (Integer, Double, Float etc.) au la dispoziție metode pentru conversia valorii interne în alte forme primitive:

Double size = new Double(32.76);
double d = size.doubleValue();  // 32.76
float f = size.floatValue();    // 32.76f
long l = size.longValue();      // 32L
int i = size.intValue();        // 32

Aceste metode sunt echivalente cu operațiile de conversie explicită (cast) între tipurile primitive.

Începând cu Java 5, conversia între tipurile primitive și wrapper se face automat:

• Autoboxing: conversie automată de la valoare primitivă la obiect wrapper;
• Unboxing: conversie inversă, de la wrapper la valoare primitivă.

int primitiveValue = 42;
Integer objectValue = primitiveValue; // autoboxing automat de la int → Integer
 
Integer anotherObject = new Integer(99);
int anotherPrimitive = anotherObject; // unboxing automat de la Integer → int
 
Integer a = 10;
Integer b = 20;
int sum = a + b; // a și b sunt unboxed automat, apoi rezultatul e autoboxed dacă e atribuit unui Integer

Compilatorul inserează conversiile în mod implicit, făcând codul mai concis și mai lizibil.

Colecțiile sunt structuri de date esențiale care permit gruparea, organizarea și manipularea eficientă a obiectelor. În Java, colecțiile oferă o modalitate standardizată de a lucra cu seturi, liste, cozi și mapări, reprezentând una dintre cele mai puternice părți ale limbajului.

La nivel de bază, Java oferă tablouri (arrays), despre care am învățat în laboratoarele trecute că sunt structuri fixe, rapide, dar inflexibile. Ele au o dimensiune fixă și nu pot crește sau micșora dinamic, ceea ce devine o limitare serioasă în aplicațiile reale.

Colecțiile au fost introduse pentru a răspunde acestor limitări, oferind structuri dinamice capabile să se redimensioneze automat și să ofere operații avansate de căutare, filtrare și sortare.

Colecțiile moderne permit:

• Creștere și micșorare dinamică a dimensiunii
• Ordine și unicități controlabile
• Abstractizarea relațiilor dintre obiecte (prin tipuri diferite de colecții)
• Eficiență în căutare și sortare datorită algoritmilor integrați

Frameworkul de colecții se bazează pe două ierarhii paralele, definite în pachetul java.util:

Fiecare colecție are un scop diferit:

• List — păstrează ordinea de inserare și permite duplicate.
• Set — elimină duplicatele, accent pe unicitate.
• Queue— gestionează elemente în ordinea procesării (FIFO sau LIFO).
• Map — asociază chei unice cu valori, oferind acces rapid după cheie.

Prin folosirea ierarhiilor de mai sus, avem următoarele beneficii:

• Interfețe standard și implementări interschimbabile
• Cod mai scurt și expresiv
• Implementări multiple optimizate pentru scopuri diferite
• Tipizare sigură prin genericitate
• Integrare nativă cu Stream API

Interfața Collection<E> definește un comportament comun pentru toate colecțiile care gestionează elemente individuale. Ea nu dictează cum sunt stocate datele, ci ce operații sunt posibile.

Un iterator este un obiect care permite traversarea unei colecţii şi modificarea acesteia (ex: ştergere de elemente) în mod selectiv. Puteţi obţine un iterator pentru o colecţie, apelând metoda sa iterator(). Interfaţa Iterator este următoarea:

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove(); // optional
}

Exemplu de folosire a unui iterator:

Collection<Double> col  = new ArrayList<Double>();
Iterator<Double> it = col.iterator();
 
while (it.hasNext()) {
    Double backup = it.next();
    // apelul it.next() trebuie realizat înainte de apelul it.remove()
    if (backup < 5.0) {
        it.remove();
    }
}

Apelul metodei remove() a unui iterator face posibilă eliminarea elementului din colecţie care a fost întors la ultimul apel al metodei next() din acelaşi iterator.

În exemplul anterior, toate elementele din colecţie mai mici decât 5 for fi şterse la ieşirea din bucla while.

Această construcţie permite (într-o manieră expeditivă) traversarea unei colecţii.

Collection collection = new ArrayList();
for (Object o : collection)
    System.out.println(o);

Construcţia for-each se bazează, în spate, pe un iterator, pe care îl ascunde. Prin urmare nu putem şterge elemente în timpul iterării.

În această manieră pot fi parcurşi şi vectori oarecare. De exemplu, collection ar fi putut fi definit ca Object[].

import java.util.*;
 
public class CollectionExample {
    public static void main(String[] args) {
        // Folosim Collection cu ArrayList ca implementare
        Collection<String> fruits = new ArrayList<>(); // Diamond operator <>
 
        // Adăugăm elemente
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
 
        // Verificăm dimensiunea și dacă este goală
        System.out.println("Dimensiune: " + fruits.size());
        System.out.println("Este goală? " + fruits.isEmpty());
 
        // Verificăm dacă un element există
        System.out.println("Conține 'Banana'? " + fruits.contains("Banana"));
 
        // Iterăm prin elemente folosind Iterator
        System.out.println("Elemente în colecție:");
        Iterator<String> it = fruits.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
 
        // Eliminăm un element
        fruits.remove("Apple");
        System.out.println("Colecție după eliminare: " + fruits);
    }
}

Un Set este o colecție fără duplicate. Elementele sunt comparate folosind metodele equals() și hashCode().

Caracteristici:

• Nu garantează ordinea elementelor (în HashSet)
• Permite elemente null (în unele implementări)
• Implementări comune:
  • HashSet – rapid, dar neordonat
  • LinkedHashSet – păstrează ordinea de inserare
  • TreeSet – menține ordinea naturală sau definită de un Comparator

import java.util.*;
 
public class HashSetExample {
    public static void main(String[] args) {
        // HashSet
        Set<String> cities = new HashSet<>();
        cities.add("Bucharest");
        cities.add("Cluj");
        cities.add("Bucharest"); // ignorat (duplicat)
 
        System.out.println(cities); // ordinea nu este garantată
        System.out.println("Conține Cluj? " + cities.contains("Cluj"));
 
        // LinkedHashSet
        Set<Integer> numbers = new LinkedHashSet<>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(2);
 
        System.out.println(numbers); // păstrează ordinea de inserare → [3, 1, 2]
 
        // TreeSet
        Set<String> names = new TreeSet<>();
        names.add("Ana");
        names.add("Ion");
        names.add("Maria");
 
        System.out.println(names); // sortat natural → [Ana, Ion, Maria]
    }
}

List este o colecție ordonată ce permite elemente duplicate și acces prin index.

Caracteristici:

• Elementele sunt stocate în ordinea de inserare.
• Poți accesa, adăuga sau elimina elemente la poziții specifice.
• Implementări comune:
  • ArrayList – acces rapid, inserări lente în mijloc
  • LinkedList – inserări rapide, acces lent la elemente
  • Vector – versiune veche, sincronizată (de obicei evitată)

import java.util.*;
 
public class ArrayListExample {
    public static void main(String[] args) {
        // ArrayList
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Apple"); // duplicatele sunt permise
 
        System.out.println(fruits); // [Apple, Banana, Apple]
        System.out.println("Primul element: " + fruits.get(0));
 
        // LinkedList
        List<String> tasks = new LinkedList<>();
        tasks.add("Wake up");
        tasks.add("Make coffee");
        tasks.addFirst("Stretch");
 
        System.out.println(tasks); // [Stretch, Wake up, Make coffee]
        tasks.removeLast();
        System.out.println(tasks); // [Stretch, Wake up]
    }
}

Queue modelează o coadă de așteptare. Elementele sunt procesate în ordinea în care sunt adăugate (FIFO).

Caracteristici:

• Ideală pentru procese asincrone sau bufferizare
• Implementări:
  • PriorityQueue - permite inserarea într-o coadă păstrând o ordine specifică
  • ArrayDeque - permite inserarea și ștergerea din ambele capete

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        // PriorityQueue
        Queue<Integer> pq = new PriorityQueue<>();
        pq.add(5);
        pq.add(1);
        pq.add(3);
 
        while (!pq.isEmpty()) {
            System.out.println(pq.poll()); // scoate în ordine: 1, 3, 5
        }
 
        // ArrayDeque (Stack)
        Deque<String> stack = new ArrayDeque<>();
        stack.push("A");
        stack.push("B");
        stack.push("C");
 
        System.out.println(stack.pop()); // C (comportament de stivă)
        System.out.println(stack);       // [B, A]
    }
}

Map<K, V> asociază chei unice cu valori. Este baza pentru implementarea tabelelor de asociere, cache-urilor și bazelor de date simple în memorie.

import java.util.*;
 
public class MapExample {
    public static void main(String[] args) {
        // HashMap
        Map<String, Integer> map = new HashMap<>();
 
        map.put("Apple", 10);
        map.put("Banana", 20);
        map.put("Cherry", 30);
        map.put("Apple", 40); // suprascrie valoarea pentru cheie "Apple"
 
        System.out.println("HashMap: " + map);
 
        // Iterare
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
        // Output HashMap (aleator pe baza metodei hashCode():
        // Banana -> 20
        // Apple -> 40
        // Cherry -> 30
 
 
        // LinkedHashMap
        LinkedHashMap<String, Integer> linkedMap = new LinkedHashMap<>();
 
        linkedMap.put("Apple", 10);
        linkedMap.put("Banana", 20);
        linkedMap.put("Cherry", 30);
 
        System.out.println("LinkedHashMap: " + linkedMap);
 
        // Iterare
        for (Map.Entry<String, Integer> entry : linkedMap.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
        // Output LinkedHashMap (ordonat pe baza inserării): 
        // Apple -> 10
        // Banana -> 20
        // Cherry -> 30 
 
 
        // TreeMap
        TreeMap<String, Integer> treeMap = new TreeMap<>();
 
        treeMap.put("Apple", 10);
        treeMap.put("Banana", 20);
        treeMap.put("Cherry", 30);
 
        System.out.println("TreeMap: " + treeMap);
 
        // Iterare
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
        // Output TreeMap (ordonat lexicografic dupa cheia String): 
        // Apple -> 10, 
        // Banana -> 20
        // Cherry -> 30
 
        // SubMap
        System.out.println("SubMap (A-C): " + treeMap.subMap("Apple", "Cherry"));
        // Output SubMap: SubMap (A-C): {Apple=10, Banana=20}
    }
}

• Standardizare – toate colecțiile urmează același set de reguli
• Performanță – implementări eficiente bazate pe algoritmi consacrați
• Tipizare sigură – prin Generics
• Extensibilitate – poți crea propriile colecții personalizate
• Compatibilitate cu Stream API – colecțiile se pot procesa funcțional

// Listă imutabilă
List<String> immutableList = List.of("Apple", "Banana", "Cherry");
immutableList.add("Orange"); // eroare
 
// Listă mutabilă
List<String> mutableList = new ArrayList<>(List.of("Apple", "Banana", "Cherry"));
mutableList.add("Orange"); // funcționează

Sortarea elementelor simple (ex. String, Integer, Float etc.) într-un ArrayList este directă, dar pentru obiecte complexe, cum ar fi o listă ArrayList<Student> sortată după media anilor, avem nevoie de Comparable sau Comparator.

class Student implements Comparable<Student> {
    private String name;
    private String surname;
 
    public Student(String name, String surname) {
        this.name = name;
        this.surname = surname;
    }
 
    // Ordonare naturală
    @Override
    public int compareTo(Student o) {
        return surname.equals(o.surname) ? name.compareTo(o.name) : surname.compareTo(o.surname);
    }
}
 
public class Main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
 
        // Sortare folosind metoda sort() din Collections
        Collections.sort(students);
    }
}

ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(5, 1, 3623, 13, 7));
 
// Sortare descrescătoare folosind Comparator anonim
Collections.sort(numbers, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});
System.out.println(numbers); // [3623, 13, 7, 5, 1]
 
// Alternativ, folosind metoda sort() din List
numbers.sort(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
});

În Java, metodele hashCode() și equals() sunt fundamentale pentru colecțiile care folosesc hashing, cum ar fi HashSet, HashMap sau LinkedHashMap. Înțelegerea lor corectă este esențială pentru a evita comportamente neașteptate.

Metoda hashCode() returnează un număr întreg care reprezintă obiectul. Acest număr este folosit de colecțiile bazate pe hash pentru a determina bucket-ul în care va fi plasat obiectul. Astfel, accesul la elemente devine rapid, aproape constant în timp.

Dacă două obiecte sunt considerate egale prin equals(), hashCode-ul lor trebuie să fie identic. Dacă hashCode-ul este diferit, obiectele sunt sigur inegale.

1. Două obiecte egale prin equals() trebuie să aibă același hashCode().
2. Două obiecte cu același hashCode() nu sunt neapărat egale.
3. Obiectele cu hash diferit sunt sigur inegale.

Definirea metodelor pentru hash:

public class Student {
    private String name;
    private int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Student other = (Student) obj;
        return age == other.age && name.equals(other.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Adăugarea în HashSet:

Set<Student> students = new HashSet<>();
students.add(new Student("Alice", 20));
students.add(new Student("Alice", 20)); // Nu se adaugă, equals() returnează true
System.out.println(students.size()); // Afișează 1

Java oferă suport nativ pentru operații aritmetice pe tipuri primitive (int, long, float, double). Pentru operații mai complexe, cum ar fi funcții trigonometrice, radăcini pătrate sau generarea de numere aleatoare, clasa java.lang.Math oferă metode statice gata de folosit. Aceasta nu poate fi instanțiată, fiind un utilitar de tip static.

Pentru aritmetica întregilor, împărțirea la zero aruncă o excepție de tip ArithmeticException. În schimb, operațiile pe numere zecimale (double/float) nu aruncă excepții, ci pot returna valori speciale precum POSITIVE_INFINITY, NEGATIVE_INFINITY sau NaN.

Tabelul de mai jos sintetizează principalele metode din clasa Math:

Tipurile primitive long și double au limite în ceea ce privește dimensiunea și precizia. Dacă ai nevoie de numere foarte mari sau de zecimale cu precizie arbitrară, poți folosi clasele BigInteger și BigDecimal din pachetul java.math.

• BigInteger permite operații aritmetice pe numere întregi de orice dimensiune, fără să apară overflow.
• BigDecimal permite operații pe numere zecimale cu precizie controlată și este ideal pentru calcule financiare sau științifice.

BigInteger b1 = new BigInteger("9223372036854775807");
BigInteger b2 = new BigInteger("2");
System.out.println(b1.add(b2)); // 9223372036854775809
 
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("3");
BigDecimal result = bd1.divide(bd2, 100, BigDecimal.ROUND_UP);
System.out.println(result); // 0.3333...3334 (100 cifre)

Aceste clase oferă metode pentru adunare, scădere, înmulțire, împărțire și control precis al rotunjirii.

Java include mai multe clase pentru manipularea timpului și a datelor:

• java.time.LocalDate – reprezintă doar data, fără timp.
• java.time.LocalTime – reprezintă doar timpul, fără dată.
• java.time.LocalDateTime – combină data și ora.
• java.time.ZonedDateTime – reprezintă un moment exact într-un fus orar, luând în calcul ajustările de vară.

Crearea instanțelor se poate face fie cu valorile numerice folosind of(), fie prin parsarea stringurilor folosind parse(). De asemenea, metoda now() returnează momentul curent.

Reprezintă o dată fără timp (ex: 2023-03-31). Ideal pentru evenimente sau zile calendaristice.

Puteți crea un obiect folosind metoda now() pentru data curentă sau of() pentru o dată specifică.

LocalDate today = LocalDate.now();
LocalDate reminder = today.plus(1, ChronoUnit.WEEKS);
System.out.println(reminder); // o săptămână de la azi

Reprezintă o oră fără dată (ex: 07:15). Util pentru alarme sau ore de evenimente recurente.

LocalTime alarm = LocalTime.of(7, 15);
System.out.println(alarm); // 07:15

Reprezintă data și timpul împreună, fără fus orar. Este util pentru programări și timestamp-uri locale.

LocalDateTime appointment = LocalDateTime.of(2023,5,4,7,0);
LocalDateTime nextAppointment = appointment.plusHours(3);
System.out.println(nextAppointment); // 2023-05-04T10:00

Reprezintă un moment exact într-un fus orar, incluzând ajustările de vară. Este esențial când aplicația se folosește în mai multe zone.

LocalDateTime piLocal = LocalDateTime.parse("2023-03-14T01:59");
ZonedDateTime piCentral = piLocal.atZone(ZoneId.of("America/Chicago"));
ZonedDateTime piParis = piCentral.withZoneSameInstant(ZoneId.of("Europe/Paris"));
System.out.println(piParis); // 2023-03-14T07:59+01:00[Europe/Paris]

Permite formatări și parsări personalizate pentru date și timp. Aceleași formate pot fi folosite și pentru parsarea string-urilor.

DateTimeFormatter military = DateTimeFormatter.ofPattern("HHmm");
LocalTime sunset = LocalTime.parse("2020", military);
System.out.println(sunset); // 20:20
 
DateTimeFormatter appointment = DateTimeFormatter.ofPattern("h:mm a MM/dd/yy z");
ZonedDateTime dentist = ZonedDateTime.parse("10:30 AM 11/01/23 EST", appointment);
System.out.println(dentist); // 2023-11-01T10:30-04:00[America/New_York]
 
LocalTime t = LocalTime.now();
System.out.println(withSeconds.format(t)); // ex: 09:17:34
System.out.println(military.format(t));    // ex: 0917

Puteți crea formate foarte variate pentru afișări personalizate folosind caracterele din DateTimeFormatter.

Clasele Instant și ChronoUnit permit manipularea timestamp-urilor precise, ideale pentru logging sau urmărirea evenimentelor:

Instant time1 = Instant.now();
Instant time2 = Instant.now();
 
System.out.println(time1.isAfter(time2)); // false
System.out.println(time1.plus(3, ChronoUnit.DAYS)); // 3 zile mai târziu

Instant este similar cu clasa veche Date, dar mult mai consistent și integrat cu java.time.

• Folosiți LocalDate pentru date fără timp și LocalTime pentru timp fără dată.
• LocalDateTime combină data și ora, dar nu include fusul orar.
• ZonedDateTime este necesar când lucrați cu aplicații globale și fusuri orare.
• DateTimeFormatter permite formatarea și parsarea flexibilă a datelor și orelor.
• Instant reprezintă un timestamp precis pentru evenimente și log-uri.

• Pachetul java.util oferă implementări ale unor stucturi de date și algoritmi pentru manipularea lor: ierarhiile Collection și Map și clasa cu metode statice Collections.
• Parcurgerea colecţiilor se face în două moduri:
  • folosind iteratori (obiecte ce permit traversarea unei colecţii şi modificarea acesteia)
  • folosind construcţia specială for each (care nu permite modificarea colecţiei în timpul parcurgerii sale)
• Interfaţa List - colecţie ordonată ce poate conţine elemente duplicate.
• Interfaţa Set - colecţie ce nu poate conţine elemente duplicate. Există trei implementări utile pentru Set: HashSet (neordonat, nesortat), TreeSet (set sortat) și LinkedHashSet (set ordonat)
• Interfaţa Map - colecţie care mapează chei pe valori. Într-o astfel de structură nu pot exista chei duplicate. Cele trei implementări pentru Map sunt HashMap (neordonat, nesortat), TreeMap (map sortat) și LinkedHashMap (map ordonat)
• Contractul equals - hashcode: dacă obj1 equals obj2 atunci hashcode obj1 == hashcode obj2. Dacă implementați equals, implementați și hashcode dacă doriți să folosiți acele obiecte în colecții bazate pe hash-uri (e.g. HashMap, HashSet).

1. În cadrul acestui exercițiu, veți implementa o clasă numită Student, care are patru membri:

1. name (String)
2. surname (String)
3. id (long)
4. averageGrade (double) - media unui student.

Clasa Student va implementa interfața Comparable<Student>, folosită la sortări, prin implementarea metodei compareTo. În metoda compareTo, studenții vor fi comparați mai întâi după medie, apoi după numele de familie, apoi după prenume. După implementarea clasei, sortați elementele listei “students” din metoda main folosind metoda Collections.sort().

2. Adăugați lista “copyStudents” într-un PriorityQueue (cu ajutorul metodei Collection.addAll), care folosește un Comparator (utilizați constructorul PriorityQueue) sau o funcție anonimă. Elementele vor fi sortate crescător după id.

3. Suprascrieți metodele equals și hashCode în clasa Student (puteți folosi generatorul de cod din IntelliJ). După aceasta, adăugați în lista asociată studentilor din “studentMap” patru materii aleatorii. Pentru a obține materiile aleatorii, urmăriți indicațiile din codul din funcția main.

4. Extindeți clasa LinkedHashSet<Integer> cu o clasă în care se vor putea adăuga doar numere pare. Metoda add va fi suprascrisă astfel încât să nu permită adăugarea de numere impare în colecție. Efectuați aceeași operațiune și pentru clasele TreeSet și HashSet. Observați diferențele privind ordinea de inserare a elementelor între cele trei clase menționate.

• Java Collections - Tutorial Point
• Java Math
• Java BigInteger
• Java BigDecimal
• Date and Time API - Baeldung