Meséljen a Java gyűjtemények hierarchiájáról.

A Java gyűjteményhierarchiája két alapvető interfész köré épül: a Collection és a Map. A java.util csomagban van meghatározva.

• Collection<E>: A legtöbb gyűjtemény alapinterfésze. Egy elemcsoportot képvisel. Nem garantálja az elemek sorrendjét vagy egyediségét.
  • List<E>: Rendezett gyűjtemény (szekvencia). Az elemeknek meghatározott indexük van. Duplicátumokat tartalmazhat.
    • ArrayList<E>: Tömb alapú implementáció. Gyors véletlenszerű hozzáférés, lassú beszúrás és törlés középen.
    • LinkedList<E>: Láncolt lista alapú implementáció. Lassú véletlenszerű hozzáférés, gyors beszúrás és törlés eleje és vége felé.
    • Vector<E>: Régi, szinkronizált osztály. Hasonló az ArrayList-hez, de szálbiztos (és kevésbé hatékony).
    • Stack<E>: Régi osztály, amely a Vector-t bővíti, és verem (LIFO) viselkedést valósít meg.
  • Set<E>: Gyűjtemény, amelyben egyedi elemek vannak.
    • HashSet<E>: Hash-tábla alapú implementáció. Nem rendezett. Gyors add, remove, contains műveletek.
    • LinkedHashSet<E>: Megőrzi a beszúrás sorrendjét.
    • SortedSet<E>: Rendezett halmaz.
      • TreeSet<E>: Piros-fekete fa alapú implementáció. Garantálja a rendezett sorrendet.
  • Queue<E>: Gyűjtemény, amely az elemeket feldolgozás előtt tárolja, gyakran FIFO sorrendben.
    • PriorityQueue<E>: Prioritási sor implementáció. Az elemek prioritás szerint kerülnek kivételre.
    • Deque<E>: (Két végű sor) Kétirányú sor. Támogatja az elemek beszúrását és kivételét mindkét végén.
      • ArrayDeque<E>: Dinamikus tömb alapú Deque implementáció. Gyorsabb, mint a LinkedList veremként vagy sorként való használatakor.
• Map<K, V>: Objektum, amely kulcsokat értékekhez rendel. A kulcsok egyediek, az értékek ismétlődhetnek.
  • HashMap<K, V>: Hash-tábla alapú implementáció. Nem rendezett. Gyors put, get, remove műveletek.
  • LinkedHashMap<K, V>: Megőrzi a beszúrás vagy hozzáférés sorrendjét.
  • SortedMap<K, V>: Rendezett térkép kulcs szerint.
    • TreeMap<K, V>: Piros-fekete fa alapú implementáció. Garantálja a rendezett sorrendet kulcs szerint.
  • Hashtable<K, V>: Régi, szinkronizált osztály. Hasonló a HashMap-hez, de szálbiztos (és kevésbé hatékony).

Fő interfészek:

Interfész	Leírás	Sorrend	Egyediség	Duplikált értékek
Collection	Elemcsoport	+/-	+/-	Igen
List	Rendezett gyűjtemény	Igen	Nem	Igen
Set	Egyedi elemek gyűjteménye	+/-	Igen	Nem
Queue	Feldolgozó gyűjtemény (FIFO)	Igen	Nem	Igen
Deque	Két végű sor	Igen	Nem	Igen
Map	Kulcs-érték párosítás	+/-	Kulcs szerint	Igen
SortedSet	Rendezett halmaz	Igen	Igen	Nem
SortedMap	Rendezett térkép kulcs szerint	Igen	Kulcs szerint	Igen

Használati példa:

// ArrayList példa
List<String> nevek = new ArrayList<>();
nevek.add("Alice");
nevek.add("Bob");
System.out.println(nevek.get(0)); // Alice

// HashSet példa
Set<Integer> egyediSzámok = new HashSet<>();
egyediSzámok.add(1);
egyediSzámok.add(2);
egyediSzámok.add(1); // Duplicátum figyelmen kívül hagyva
System.out.println(egyediSzámok.size()); // 2

// HashMap példa
Map<String, Integer> életkorok = new HashMap<>();
életkorok.put("Alice", 30);
életkorok.put("Bob", 25);
System.out.println(életkorok.get("Alice")); // 30